@layers/client 0.1.1-alpha.1 → 1.0.0

package/dist/react.d.ts

@@ -0,0 +1,105 @@
+import { g as EventProperties, n as LayersClient, p as ConsentState, r as LayersConfig } from "./index-C1d8NEFV.js";
+import { ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/react.d.ts
+interface LayersProviderProps {
+  config: LayersConfig;
+  children: ReactNode;
+}
+/**
+ * Provides a LayersClient instance to the React component tree.
+ * Initializes the client on mount and shuts it down on unmount.
+ *
+ * @example
+ * ```tsx
+ * import { LayersProvider } from '@layers/client/react';
+ *
+ * function App() {
+ *   return (
+ *     <LayersProvider config={{ apiKey: 'key', appId: 'app', environment: 'production' }}>
+ *       <MyApp />
+ *     </LayersProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function LayersProvider({
+  config,
+  children
+}: LayersProviderProps): react_jsx_runtime0.JSX.Element;
+/**
+ * Returns the LayersClient instance from the nearest LayersProvider.
+ * Throws if used outside a LayersProvider.
+ */
+declare function useLayers(): LayersClient;
+/**
+ * Returns a stable, memoized track function bound to the current LayersClient.
+ *
+ * @example
+ * ```tsx
+ * import { useTrack } from '@layers/client/react';
+ *
+ * function SignupButton() {
+ *   const track = useTrack();
+ *   return <button onClick={() => track('signup_click', { source: 'hero' })}>Sign up</button>;
+ * }
+ * ```
+ */
+declare function useTrack(): (eventName: string, properties?: EventProperties) => void;
+/**
+ * Returns a stable, memoized screen function bound to the current LayersClient.
+ *
+ * @example
+ * ```tsx
+ * import { useScreen } from '@layers/client/react';
+ * import { useEffect } from 'react';
+ *
+ * function Dashboard() {
+ *   const screen = useScreen();
+ *   useEffect(() => { screen('dashboard'); }, [screen]);
+ *   return <div>Dashboard</div>;
+ * }
+ * ```
+ */
+declare function useScreen(): (screenName: string, properties?: EventProperties) => void;
+/**
+ * Returns a stable, memoized identify function that sets the app user ID on the current LayersClient.
+ * Pass `undefined` to clear the current user ID.
+ *
+ * @example
+ * ```tsx
+ * import { useIdentify } from '@layers/client/react';
+ *
+ * function LoginForm() {
+ *   const identify = useIdentify();
+ *   const onLogin = (userId: string) => identify(userId);
+ *   const onLogout = () => identify(undefined);
+ * }
+ * ```
+ */
+declare function useIdentify(): (userId: string | undefined) => void;
+/**
+ * Returns stable, memoized consent functions bound to the current LayersClient.
+ *
+ * @example
+ * ```tsx
+ * import { useConsent } from '@layers/client/react';
+ *
+ * function ConsentBanner() {
+ *   const { setConsent, getConsentState } = useConsent();
+ *   return (
+ *     <button onClick={() => setConsent({ analytics: true, advertising: false })}>
+ *       Accept Analytics Only
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useConsent(): {
+  setConsent: (consent: ConsentState) => void;
+  getConsentState: () => ConsentState;
+};
+//#endregion
+export { LayersProvider, LayersProviderProps, useConsent, useIdentify, useLayers, useScreen, useTrack };
+//# sourceMappingURL=react.d.ts.map

package/dist/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","names":[],"sources":["../src/react.tsx"],"sourcesContent":[],"mappings":";;;;;UAQiB,mBAAA;UACP;EADO,QAAA,EAEL,SAFK;AAsBjB;;;;;;AA8BA;AAqBA;AAyBA;AAyBA;AA2BA;;;;;;;;iBAhIgB,cAAA;;;GAAqC,sBAAmB,kBAAA,CAAA,GAAA,CAAA;;;;;iBA8BxD,SAAA,CAAA,GAAa;;;;;;;;;;;;;;iBAqBb,QAAA,CAAA,oCAA6C;;;;;;;;;;;;;;;;iBAyB7C,SAAA,CAAA,qCAA+C;;;;;;;;;;;;;;;;iBAyB/C,WAAA,CAAA;;;;;;;;;;;;;;;;;;iBA2BA,UAAA,CAAA;wBACQ;yBACC"}

package/dist/react.js

@@ -0,0 +1,142 @@
+import { t as LayersClient } from "./src-SyPoXjEy.js";
+import { createContext, useCallback, useContext, useEffect, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/react.tsx
+const LayersContext = createContext(null);
+/**
+* Provides a LayersClient instance to the React component tree.
+* Initializes the client on mount and shuts it down on unmount.
+*
+* @example
+* ```tsx
+* import { LayersProvider } from '@layers/client/react';
+*
+* function App() {
+*   return (
+*     <LayersProvider config={{ apiKey: 'key', appId: 'app', environment: 'production' }}>
+*       <MyApp />
+*     </LayersProvider>
+*   );
+* }
+* ```
+*/
+function LayersProvider({ config, children }) {
+	const clientRef = useRef(null);
+	if (clientRef.current === null) clientRef.current = new LayersClient(config);
+	useEffect(() => {
+		const client = clientRef.current;
+		if (!client) return;
+		client.init();
+		return () => {
+			client.shutdown();
+			clientRef.current = null;
+		};
+	}, []);
+	return /* @__PURE__ */ jsx(LayersContext.Provider, {
+		value: clientRef.current,
+		children
+	});
+}
+/**
+* Returns the LayersClient instance from the nearest LayersProvider.
+* Throws if used outside a LayersProvider.
+*/
+function useLayers() {
+	const client = useContext(LayersContext);
+	if (!client) throw new Error("useLayers must be used within a <LayersProvider>");
+	return client;
+}
+/**
+* Returns a stable, memoized track function bound to the current LayersClient.
+*
+* @example
+* ```tsx
+* import { useTrack } from '@layers/client/react';
+*
+* function SignupButton() {
+*   const track = useTrack();
+*   return <button onClick={() => track('signup_click', { source: 'hero' })}>Sign up</button>;
+* }
+* ```
+*/
+function useTrack() {
+	const client = useLayers();
+	return useCallback((eventName, properties) => {
+		client.track(eventName, properties);
+	}, [client]);
+}
+/**
+* Returns a stable, memoized screen function bound to the current LayersClient.
+*
+* @example
+* ```tsx
+* import { useScreen } from '@layers/client/react';
+* import { useEffect } from 'react';
+*
+* function Dashboard() {
+*   const screen = useScreen();
+*   useEffect(() => { screen('dashboard'); }, [screen]);
+*   return <div>Dashboard</div>;
+* }
+* ```
+*/
+function useScreen() {
+	const client = useLayers();
+	return useCallback((screenName, properties) => {
+		client.screen(screenName, properties);
+	}, [client]);
+}
+/**
+* Returns a stable, memoized identify function that sets the app user ID on the current LayersClient.
+* Pass `undefined` to clear the current user ID.
+*
+* @example
+* ```tsx
+* import { useIdentify } from '@layers/client/react';
+*
+* function LoginForm() {
+*   const identify = useIdentify();
+*   const onLogin = (userId: string) => identify(userId);
+*   const onLogout = () => identify(undefined);
+* }
+* ```
+*/
+function useIdentify() {
+	const client = useLayers();
+	return useCallback((userId) => {
+		client.setAppUserId(userId);
+	}, [client]);
+}
+/**
+* Returns stable, memoized consent functions bound to the current LayersClient.
+*
+* @example
+* ```tsx
+* import { useConsent } from '@layers/client/react';
+*
+* function ConsentBanner() {
+*   const { setConsent, getConsentState } = useConsent();
+*   return (
+*     <button onClick={() => setConsent({ analytics: true, advertising: false })}>
+*       Accept Analytics Only
+*     </button>
+*   );
+* }
+* ```
+*/
+function useConsent() {
+	const client = useLayers();
+	return {
+		setConsent: useCallback((consent) => {
+			client.setConsent(consent);
+		}, [client]),
+		getConsentState: useCallback(() => {
+			return client.getConsentState();
+		}, [client])
+	};
+}
+
+//#endregion
+export { LayersProvider, useConsent, useIdentify, useLayers, useScreen, useTrack };
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","names":[],"sources":["../src/react.tsx"],"sourcesContent":["import { createContext, useCallback, useContext, useEffect, useRef } from 'react';\nimport type { ReactNode } from 'react';\n\nimport { LayersClient } from './index.js';\nimport type { ConsentState, EventProperties, LayersConfig } from './index.js';\n\nconst LayersContext = createContext<LayersClient | null>(null);\n\nexport interface LayersProviderProps {\n  config: LayersConfig;\n  children: ReactNode;\n}\n\n/**\n * Provides a LayersClient instance to the React component tree.\n * Initializes the client on mount and shuts it down on unmount.\n *\n * @example\n * ```tsx\n * import { LayersProvider } from '@layers/client/react';\n *\n * function App() {\n *   return (\n *     <LayersProvider config={{ apiKey: 'key', appId: 'app', environment: 'production' }}>\n *       <MyApp />\n *     </LayersProvider>\n *   );\n * }\n * ```\n */\nexport function LayersProvider({ config, children }: LayersProviderProps) {\n  const clientRef = useRef<LayersClient | null>(null);\n\n  if (clientRef.current === null) {\n    clientRef.current = new LayersClient(config);\n  }\n\n  useEffect(() => {\n    const client = clientRef.current;\n    if (!client) return;\n\n    void client.init();\n\n    return () => {\n      client.shutdown();\n      clientRef.current = null;\n    };\n    // Config is intentionally captured once at mount time via useRef above.\n    // Re-creating the client on every config change would lose in-flight events\n    // and session state, so we suppress the exhaustive-deps warning here.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  return <LayersContext.Provider value={clientRef.current}>{children}</LayersContext.Provider>;\n}\n\n/**\n * Returns the LayersClient instance from the nearest LayersProvider.\n * Throws if used outside a LayersProvider.\n */\nexport function useLayers(): LayersClient {\n  const client = useContext(LayersContext);\n  if (!client) {\n    throw new Error('useLayers must be used within a <LayersProvider>');\n  }\n  return client;\n}\n\n/**\n * Returns a stable, memoized track function bound to the current LayersClient.\n *\n * @example\n * ```tsx\n * import { useTrack } from '@layers/client/react';\n *\n * function SignupButton() {\n *   const track = useTrack();\n *   return <button onClick={() => track('signup_click', { source: 'hero' })}>Sign up</button>;\n * }\n * ```\n */\nexport function useTrack(): (eventName: string, properties?: EventProperties) => void {\n  const client = useLayers();\n  return useCallback(\n    (eventName: string, properties?: EventProperties) => {\n      void client.track(eventName, properties);\n    },\n    [client]\n  );\n}\n\n/**\n * Returns a stable, memoized screen function bound to the current LayersClient.\n *\n * @example\n * ```tsx\n * import { useScreen } from '@layers/client/react';\n * import { useEffect } from 'react';\n *\n * function Dashboard() {\n *   const screen = useScreen();\n *   useEffect(() => { screen('dashboard'); }, [screen]);\n *   return <div>Dashboard</div>;\n * }\n * ```\n */\nexport function useScreen(): (screenName: string, properties?: EventProperties) => void {\n  const client = useLayers();\n  return useCallback(\n    (screenName: string, properties?: EventProperties) => {\n      void client.screen(screenName, properties);\n    },\n    [client]\n  );\n}\n\n/**\n * Returns a stable, memoized identify function that sets the app user ID on the current LayersClient.\n * Pass `undefined` to clear the current user ID.\n *\n * @example\n * ```tsx\n * import { useIdentify } from '@layers/client/react';\n *\n * function LoginForm() {\n *   const identify = useIdentify();\n *   const onLogin = (userId: string) => identify(userId);\n *   const onLogout = () => identify(undefined);\n * }\n * ```\n */\nexport function useIdentify(): (userId: string | undefined) => void {\n  const client = useLayers();\n  return useCallback(\n    (userId: string | undefined) => {\n      client.setAppUserId(userId);\n    },\n    [client]\n  );\n}\n\n/**\n * Returns stable, memoized consent functions bound to the current LayersClient.\n *\n * @example\n * ```tsx\n * import { useConsent } from '@layers/client/react';\n *\n * function ConsentBanner() {\n *   const { setConsent, getConsentState } = useConsent();\n *   return (\n *     <button onClick={() => setConsent({ analytics: true, advertising: false })}>\n *       Accept Analytics Only\n *     </button>\n *   );\n * }\n * ```\n */\nexport function useConsent(): {\n  setConsent: (consent: ConsentState) => void;\n  getConsentState: () => ConsentState;\n} {\n  const client = useLayers();\n  const setConsent = useCallback(\n    (consent: ConsentState) => {\n      client.setConsent(consent);\n    },\n    [client]\n  );\n  const getConsentState = useCallback(() => {\n    return client.getConsentState();\n  }, [client]);\n  return { setConsent, getConsentState };\n}\n"],"mappings":";;;;;AAMA,MAAM,gBAAgB,cAAmC,KAAK;;;;;;;;;;;;;;;;;;AAwB9D,SAAgB,eAAe,EAAE,QAAQ,YAAiC;CACxE,MAAM,YAAY,OAA4B,KAAK;AAEnD,KAAI,UAAU,YAAY,KACxB,WAAU,UAAU,IAAI,aAAa,OAAO;AAG9C,iBAAgB;EACd,MAAM,SAAS,UAAU;AACzB,MAAI,CAAC,OAAQ;AAEb,EAAK,OAAO,MAAM;AAElB,eAAa;AACX,UAAO,UAAU;AACjB,aAAU,UAAU;;IAMrB,EAAE,CAAC;AAEN,QAAO,oBAAC,cAAc;EAAS,OAAO,UAAU;EAAU;GAAkC;;;;;;AAO9F,SAAgB,YAA0B;CACxC,MAAM,SAAS,WAAW,cAAc;AACxC,KAAI,CAAC,OACH,OAAM,IAAI,MAAM,mDAAmD;AAErE,QAAO;;;;;;;;;;;;;;;AAgBT,SAAgB,WAAsE;CACpF,MAAM,SAAS,WAAW;AAC1B,QAAO,aACJ,WAAmB,eAAiC;AACnD,EAAK,OAAO,MAAM,WAAW,WAAW;IAE1C,CAAC,OAAO,CACT;;;;;;;;;;;;;;;;;AAkBH,SAAgB,YAAwE;CACtF,MAAM,SAAS,WAAW;AAC1B,QAAO,aACJ,YAAoB,eAAiC;AACpD,EAAK,OAAO,OAAO,YAAY,WAAW;IAE5C,CAAC,OAAO,CACT;;;;;;;;;;;;;;;;;AAkBH,SAAgB,cAAoD;CAClE,MAAM,SAAS,WAAW;AAC1B,QAAO,aACJ,WAA+B;AAC9B,SAAO,aAAa,OAAO;IAE7B,CAAC,OAAO,CACT;;;;;;;;;;;;;;;;;;;AAoBH,SAAgB,aAGd;CACA,MAAM,SAAS,WAAW;AAU1B,QAAO;EAAE,YATU,aAChB,YAA0B;AACzB,UAAO,WAAW,QAAQ;KAE5B,CAAC,OAAO,CACT;EAIoB,iBAHG,kBAAkB;AACxC,UAAO,OAAO,iBAAiB;KAC9B,CAAC,OAAO,CAAC;EAC0B"}

package/dist/src-SyPoXjEy.js

@@ -0,0 +1,399 @@
+import { FetchHttpClient, LayersCore, LayersError as LayersError$1, createDefaultPersistence } from "@layers/core-wasm";
+
+//#region src/attribution.ts
+const CLICK_ID_PARAMS = [
+	"fbclid",
+	"gclid",
+	"gbraid",
+	"wbraid",
+	"ttclid",
+	"msclkid",
+	"rclid"
+];
+const UTM_PARAMS = [
+	"utm_source",
+	"utm_medium",
+	"utm_campaign",
+	"utm_content",
+	"utm_term"
+];
+const STORAGE_KEY = "layers_attribution";
+const TTL_MS = 720 * 60 * 60 * 1e3;
+/**
+* Capture attribution signals from the current page URL and referrer.
+* Persists to localStorage with a 30-day TTL. Click IDs take priority:
+* if a new click ID is present, the entire record is overwritten.
+*/
+function captureAttribution() {
+	if (typeof window === "undefined" || typeof localStorage === "undefined") return;
+	let params;
+	try {
+		params = new URLSearchParams(window.location.search);
+	} catch {
+		return;
+	}
+	let clickIdParam;
+	let clickIdValue;
+	for (const param of CLICK_ID_PARAMS) {
+		const value = params.get(param);
+		if (value) {
+			clickIdParam = param;
+			clickIdValue = value;
+			break;
+		}
+	}
+	const utms = {};
+	let hasUtm = false;
+	for (const param of UTM_PARAMS) {
+		const value = params.get(param);
+		if (value) {
+			utms[param] = value;
+			hasUtm = true;
+		}
+	}
+	const referrer = typeof document !== "undefined" && document.referrer ? document.referrer : void 0;
+	if (!clickIdParam && !hasUtm && !referrer) return;
+	const existing = getAttribution();
+	if (clickIdParam) {
+		writeAttribution({
+			click_id_param: clickIdParam,
+			...clickIdValue != null && { click_id_value: clickIdValue },
+			...utms,
+			...referrer != null && { referrer_url: referrer },
+			captured_at: Date.now()
+		});
+		return;
+	}
+	if (hasUtm) {
+		writeAttribution({
+			...existing?.click_id_param != null && { click_id_param: existing.click_id_param },
+			...existing?.click_id_value != null && { click_id_value: existing.click_id_value },
+			...utms,
+			...referrer != null && { referrer_url: referrer },
+			captured_at: Date.now()
+		});
+		return;
+	}
+	if (!existing) writeAttribution({
+		...referrer != null && { referrer_url: referrer },
+		captured_at: Date.now()
+	});
+}
+/**
+* Read stored attribution data, returning null if missing or expired.
+*/
+function getAttribution() {
+	if (typeof localStorage === "undefined") return null;
+	try {
+		const raw = localStorage.getItem(STORAGE_KEY);
+		if (!raw) return null;
+		const data = JSON.parse(raw);
+		if (Date.now() - data.captured_at > TTL_MS) {
+			localStorage.removeItem(STORAGE_KEY);
+			return null;
+		}
+		return data;
+	} catch {
+		return null;
+	}
+}
+/**
+* Return a flat property bag suitable for merging into event properties.
+* Keys are prefixed with `$attribution_` to avoid collisions.
+*/
+function getAttributionProperties() {
+	const data = getAttribution();
+	if (!data) return {};
+	const props = {};
+	if (data.click_id_param) props["$attribution_click_id_param"] = data.click_id_param;
+	if (data.click_id_value) props["$attribution_click_id_value"] = data.click_id_value;
+	if (data.utm_source) props["$attribution_utm_source"] = data.utm_source;
+	if (data.utm_medium) props["$attribution_utm_medium"] = data.utm_medium;
+	if (data.utm_campaign) props["$attribution_utm_campaign"] = data.utm_campaign;
+	if (data.utm_content) props["$attribution_utm_content"] = data.utm_content;
+	if (data.utm_term) props["$attribution_utm_term"] = data.utm_term;
+	if (data.referrer_url) props["$attribution_referrer_url"] = data.referrer_url;
+	return props;
+}
+function writeAttribution(data) {
+	try {
+		localStorage.setItem(STORAGE_KEY, JSON.stringify(data));
+	} catch {}
+}
+
+//#endregion
+//#region src/index.ts
+var LayersClient = class {
+	core;
+	appUserId;
+	isOnline = true;
+	enableDebug;
+	baseUrl;
+	onlineListener = null;
+	offlineListener = null;
+	visibilityListener = null;
+	beforeUnloadListener = null;
+	errorListeners = /* @__PURE__ */ new Set();
+	constructor(config) {
+		this.enableDebug = config.enableDebug ?? false;
+		this.baseUrl = (config.baseUrl ?? "https://in.layers.com").replace(/\/$/, "");
+		this.appUserId = config.appUserId;
+		const persistence = createDefaultPersistence(config.appId);
+		const httpClient = new FetchHttpClient();
+		this.core = LayersCore.init({
+			config: {
+				apiKey: config.apiKey,
+				appId: config.appId,
+				environment: config.environment,
+				...config.baseUrl != null && { baseUrl: config.baseUrl },
+				...config.enableDebug != null && { enableDebug: config.enableDebug },
+				...config.flushIntervalMs != null && { flushIntervalMs: config.flushIntervalMs },
+				...config.flushThreshold != null && { flushThreshold: config.flushThreshold },
+				...config.maxQueueSize != null && { maxQueueSize: config.maxQueueSize },
+				sdkVersion: `client/${SDK_VERSION}`
+			},
+			httpClient,
+			persistence
+		});
+		if (this.appUserId) this.core.identify(this.appUserId);
+	}
+	/** Initialize the client: detects device info, attaches lifecycle listeners, and fetches remote config. */
+	async init() {
+		this.initializeDeviceInfo();
+		this.setupNetworkListener();
+		this.setupLifecycleListeners();
+		captureAttribution();
+		await this.core.fetchRemoteConfig().catch(() => {});
+	}
+	/**
+	* Record a custom analytics event with an optional property bag.
+	*
+	* Events are batched and flushed automatically when the queue reaches
+	* `flushThreshold` or the periodic flush timer fires.
+	*/
+	track(eventName, properties) {
+		if (this.enableDebug) console.log(`[Layers] track("${eventName}", ${Object.keys(properties ?? {}).length} properties)`);
+		try {
+			const merged = {
+				...getAttributionProperties(),
+				...properties
+			};
+			this.core.track(eventName, merged, this.appUserId);
+		} catch (e) {
+			this.emitError(e);
+		}
+	}
+	/**
+	* Record a screen view event with an optional property bag.
+	*
+	* Events are batched and flushed automatically when the queue reaches
+	* `flushThreshold` or the periodic flush timer fires.
+	*/
+	screen(screenName, properties) {
+		if (this.enableDebug) console.log(`[Layers] screen("${screenName}", ${Object.keys(properties ?? {}).length} properties)`);
+		try {
+			const merged = {
+				...getAttributionProperties(),
+				...properties
+			};
+			this.core.screen(screenName, merged, this.appUserId);
+		} catch (e) {
+			this.emitError(e);
+		}
+	}
+	/** Set or update user-level properties that persist across sessions. */
+	setUserProperties(properties) {
+		this.core.setUserProperties(properties);
+	}
+	/** Update the user's consent state for analytics and advertising data collection. */
+	setConsent(consent) {
+		this.core.setConsent(consent);
+	}
+	/** Associate all subsequent events with the given user ID, or clear it with `undefined`. */
+	setAppUserId(appUserId) {
+		if (this.enableDebug) console.log(`[Layers] setAppUserId(${appUserId ? `"${appUserId}"` : "undefined"})`);
+		this.appUserId = appUserId;
+		if (appUserId) this.core.identify(appUserId);
+		else this.core.identify("");
+	}
+	/** @deprecated Use setAppUserId instead */
+	setUserId(userId) {
+		this.setAppUserId(userId);
+	}
+	/** Return the current app user ID, or `undefined` if not set. */
+	getAppUserId() {
+		return this.appUserId;
+	}
+	/** @deprecated Use getAppUserId instead */
+	getUserId() {
+		return this.appUserId;
+	}
+	/** Return the current anonymous session ID. */
+	getSessionId() {
+		return this.core.getSessionId();
+	}
+	/** Return the current consent state for analytics and advertising. */
+	getConsentState() {
+		return this.core.getConsentState();
+	}
+	/** Override device-level context fields (platform, OS, locale, etc.). */
+	setDeviceInfo(deviceInfo) {
+		this.core.setDeviceContext(deviceInfo);
+	}
+	/** Flush all queued events to the server. Falls back to synchronous persistence on failure. */
+	async flush() {
+		try {
+			await this.core.flushAsync();
+		} catch (e) {
+			this.emitError(e);
+			this.core.flush();
+		}
+	}
+	/** Immediately shut down the client, removing all event listeners. Queued events are persisted but not flushed. */
+	shutdown() {
+		this.cleanupListeners();
+		this.core.shutdown();
+	}
+	/**
+	* Async shutdown: flushes remaining events before shutting down.
+	* @param timeoutMs Maximum time to wait for flush (default 3000ms).
+	*/
+	async shutdownAsync(timeoutMs = 3e3) {
+		this.cleanupListeners();
+		try {
+			await Promise.race([this.core.flushAsync(), new Promise((resolve) => setTimeout(resolve, timeoutMs))]);
+		} catch {}
+		this.core.shutdown();
+	}
+	cleanupListeners() {
+		if (typeof window !== "undefined") {
+			if (this.onlineListener) {
+				window.removeEventListener("online", this.onlineListener);
+				this.onlineListener = null;
+			}
+			if (this.offlineListener) {
+				window.removeEventListener("offline", this.offlineListener);
+				this.offlineListener = null;
+			}
+			if (this.beforeUnloadListener) {
+				window.removeEventListener("beforeunload", this.beforeUnloadListener);
+				this.beforeUnloadListener = null;
+			}
+		}
+		if (typeof document !== "undefined" && this.visibilityListener) {
+			document.removeEventListener("visibilitychange", this.visibilityListener);
+			this.visibilityListener = null;
+		}
+	}
+	/** End the current session and start a new one with a fresh session ID. */
+	startNewSession() {
+		this.core.startNewSession();
+	}
+	/**
+	* Register an error listener. Errors from track/screen/flush
+	* that would otherwise be silently dropped are forwarded here.
+	*/
+	on(event, listener) {
+		if (event === "error") this.errorListeners.add(listener);
+		return this;
+	}
+	/**
+	* Remove a previously registered error listener.
+	*/
+	off(event, listener) {
+		if (event === "error") this.errorListeners.delete(listener);
+		return this;
+	}
+	emitError(error) {
+		const err = error instanceof Error ? error : new Error(String(error));
+		for (const listener of this.errorListeners) try {
+			listener(err);
+		} catch {}
+		if (this.enableDebug && this.errorListeners.size === 0) console.warn("[Layers]", err.message);
+	}
+	initializeDeviceInfo() {
+		const context = {
+			platform: "web",
+			osVersion: this.detectOS(),
+			appVersion: SDK_VERSION,
+			deviceModel: this.detectDeviceModel(),
+			locale: this.detectLocale(),
+			screenSize: this.detectScreenSize()
+		};
+		this.core.setDeviceContext(context);
+	}
+	detectOS() {
+		if (typeof navigator === "undefined") return "unknown";
+		const ua = navigator.userAgent;
+		if (ua.includes("Windows")) return "Windows";
+		if (ua.includes("Mac OS")) return "macOS";
+		if (ua.includes("Linux")) return "Linux";
+		if (ua.includes("Android")) return "Android";
+		if (ua.includes("iPhone") || ua.includes("iPad")) return "iOS";
+		return "unknown";
+	}
+	detectDeviceModel() {
+		if (typeof navigator === "undefined") return "unknown";
+		if ("userAgentData" in navigator) {
+			const uaData = navigator.userAgentData;
+			if (uaData?.platform) return uaData.platform;
+		}
+		return navigator.platform ?? "unknown";
+	}
+	detectLocale() {
+		if (typeof navigator === "undefined") return "en-US";
+		return navigator.language ?? "en-US";
+	}
+	detectScreenSize() {
+		if (typeof window === "undefined" || typeof screen === "undefined") return "unknown";
+		return `${screen.width}x${screen.height}`;
+	}
+	setupNetworkListener() {
+		if (typeof window === "undefined") return;
+		this.isOnline = navigator?.onLine ?? true;
+		this.onlineListener = () => {
+			this.isOnline = true;
+			this.core.flushAsync().catch(() => {});
+		};
+		this.offlineListener = () => {
+			this.isOnline = false;
+		};
+		window.addEventListener("online", this.onlineListener);
+		window.addEventListener("offline", this.offlineListener);
+	}
+	getBeaconUrl() {
+		return `${this.baseUrl}/events`;
+	}
+	setupLifecycleListeners() {
+		if (typeof window === "undefined" || typeof document === "undefined") return;
+		this.visibilityListener = () => {
+			if (document.visibilityState === "hidden") {
+				if (typeof navigator !== "undefined" && navigator.sendBeacon && this.core.queueDepth() > 0) try {
+					const batch = this.core.createBeaconPayload();
+					if (batch) {
+						if (navigator.sendBeacon(this.getBeaconUrl(), batch)) {
+							this.core.clearBeaconEvents();
+							return;
+						}
+						this.core.requeueBeaconEvents();
+						this.core.flush();
+						return;
+					}
+				} catch {
+					this.core.requeueBeaconEvents();
+				}
+				this.core.flush();
+			}
+		};
+		document.addEventListener("visibilitychange", this.visibilityListener);
+		this.beforeUnloadListener = () => {
+			this.core.flush();
+		};
+		window.addEventListener("beforeunload", this.beforeUnloadListener);
+	}
+};
+const SDK_VERSION = typeof __LAYERS_CLIENT_VERSION__ !== "undefined" ? __LAYERS_CLIENT_VERSION__ : "0.1.1-alpha.1";
+
+//#endregion
+export { getAttributionProperties as i, LayersError$1 as n, getAttribution as r, LayersClient as t };
+//# sourceMappingURL=src-SyPoXjEy.js.map