@layers/client 1.4.10 → 2.0.0

package/dist/src-DnOWq7k2.js

@@ -0,0 +1,1305 @@
+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/capi.ts
+/**
+* Read a named cookie from document.cookie.
+* Returns the cookie value or undefined if not found / unavailable.
+*/
+function getCookie(name) {
+	if (typeof document === "undefined" || !document.cookie) return void 0;
+	const prefix = `${name}=`;
+	const cookies = document.cookie.split("; ");
+	for (const cookie of cookies) if (cookie.startsWith(prefix)) return decodeURIComponent(cookie.slice(prefix.length));
+}
+/**
+* Read Meta's _fbp cookie.
+* Format set by Meta Pixel: fb.1.{timestamp}.{random}
+*/
+function getFbpCookie() {
+	return getCookie("_fbp");
+}
+/**
+* Read TikTok's _ttp cookie.
+*/
+function getTtpCookie() {
+	return getCookie("_ttp");
+}
+/**
+* Capture the current page URL.
+* Required by Meta CAPI for every web event (event_source_url).
+*/
+function getPageUrl() {
+	if (typeof window === "undefined") return void 0;
+	try {
+		return window.location.href;
+	} catch {
+		return;
+	}
+}
+/**
+* Format an fbclid value into Meta's fbc cookie format.
+* Format: fb.1.{timestamp_ms}.{fbclid}
+*
+* @param fbclid - The raw fbclid parameter value from the URL
+* @param timestampMs - Optional timestamp in milliseconds (defaults to Date.now())
+*/
+function formatFbc(fbclid, timestampMs) {
+	return `fb.1.${timestampMs ?? Date.now()}.${fbclid}`;
+}
+/**
+* Get the fbc value. Checks in order:
+* 1. If an fbclid URL parameter is present, format it as fbc
+* 2. If an _fbc cookie exists, return it
+* 3. Return undefined
+*/
+function getFbc() {
+	if (typeof window !== "undefined") try {
+		const fbclid = new URLSearchParams(window.location.search).get("fbclid");
+		if (fbclid) return formatFbc(fbclid);
+	} catch {}
+	return getCookie("_fbc");
+}
+/**
+* Build the full set of CAPI properties for an event.
+* All values are optional — only present keys are included.
+*/
+function getCapiProperties() {
+	const props = {};
+	const fbp = getFbpCookie();
+	if (fbp) props["$fbp"] = fbp;
+	const ttp = getTtpCookie();
+	if (ttp) props["$ttp"] = ttp;
+	const pageUrl = getPageUrl();
+	if (pageUrl) props["$page_url"] = pageUrl;
+	const fbc = getFbc();
+	if (fbc) props["$fbc"] = fbc;
+	return props;
+}
+
+//#endregion
+//#region src/debug-overlay.ts
+const OVERLAY_ID = "layers-debug-overlay";
+const OVERLAY_STYLES = `
+  position: fixed;
+  bottom: 8px;
+  right: 8px;
+  width: 360px;
+  max-height: 400px;
+  background: rgba(0, 0, 0, 0.88);
+  color: #e0e0e0;
+  font-family: monospace;
+  font-size: 11px;
+  line-height: 1.5;
+  padding: 12px;
+  border-radius: 8px;
+  z-index: 999999;
+  overflow-y: auto;
+  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.3);
+  pointer-events: auto;
+`;
+let overlayElement = null;
+let updateInterval = null;
+/**
+* Create and display the debug overlay in the DOM.
+* Updates every second with the latest state from the provider.
+*/
+function enableDebugOverlay(stateProvider) {
+	if (typeof document === "undefined") return;
+	if (overlayElement) disableDebugOverlay();
+	overlayElement = document.createElement("div");
+	overlayElement.id = OVERLAY_ID;
+	overlayElement.setAttribute("style", OVERLAY_STYLES);
+	document.body.appendChild(overlayElement);
+	const update = () => {
+		if (!overlayElement) return;
+		overlayElement.innerHTML = renderOverlay(stateProvider());
+	};
+	update();
+	updateInterval = setInterval(update, 1e3);
+}
+/**
+* Remove the debug overlay from the DOM and stop updates.
+*/
+function disableDebugOverlay() {
+	if (updateInterval) {
+		clearInterval(updateInterval);
+		updateInterval = null;
+	}
+	if (overlayElement && overlayElement.parentNode) overlayElement.parentNode.removeChild(overlayElement);
+	overlayElement = null;
+}
+function renderOverlay(state) {
+	const lines = [
+		`<div style="font-size:13px;font-weight:bold;margin-bottom:8px;">Layers Debug ${state.isOnline ? "&#x1F7E2;" : "&#x1F534;"}</div>`,
+		`<div><b>SDK:</b> ${escapeHtml(state.sdkVersion)}</div>`,
+		`<div><b>App:</b> ${escapeHtml(state.appId)} (${escapeHtml(state.environment)})</div>`,
+		`<div><b>Session:</b> ${escapeHtml(truncate(state.sessionId, 20))}</div>`,
+		`<div><b>Install:</b> ${escapeHtml(truncate(state.installId ?? "N/A", 20))}</div>`,
+		`<div><b>Queue:</b> ${String(state.queueDepth)} events</div>`,
+		`<div><b>Network:</b> ${state.isOnline ? "Online" : "Offline"}</div>`
+	];
+	if (state.recentEvents.length > 0) {
+		lines.push(`<div style="margin-top:8px;font-weight:bold;border-top:1px solid #444;padding-top:6px;">Recent Events</div>`);
+		for (const event of state.recentEvents.slice(0, 10)) lines.push(`<div style="color:#aaa;">${escapeHtml(event)}</div>`);
+	} else lines.push(`<div style="margin-top:8px;color:#888;">No events tracked yet</div>`);
+	return lines.join("");
+}
+function escapeHtml(str) {
+	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function truncate(str, maxLen) {
+	if (str.length <= maxLen) return str;
+	return `${str.slice(0, maxLen)}...`;
+}
+
+//#endregion
+//#region src/deep-links.ts
+/**
+* Parse a URL string into structured DeepLinkData.
+* Returns null if the URL cannot be parsed.
+*/
+function parseDeepLink(url) {
+	try {
+		const parsed = new URL(url);
+		const params = {};
+		parsed.searchParams.forEach((value, key) => {
+			params[key] = value;
+		});
+		return {
+			url,
+			scheme: parsed.protocol.replace(":", ""),
+			host: parsed.hostname,
+			path: parsed.pathname,
+			queryParams: params,
+			timestamp: Date.now()
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Set up a listener for URL changes in a web browser context.
+* Listens for `popstate` and `hashchange` events and calls the callback
+* with parsed deep link data on each URL change.
+*
+* Returns an unsubscribe function to remove the listeners.
+*/
+function setupDeepLinkListener(onDeepLink) {
+	if (typeof window === "undefined" || !window.location) return () => {};
+	let lastUrl;
+	try {
+		lastUrl = window.location.href;
+	} catch {
+		return () => {};
+	}
+	const handleUrlChange = () => {
+		const currentUrl = window.location.href;
+		if (currentUrl === lastUrl) return;
+		lastUrl = currentUrl;
+		const parsed = parseDeepLink(currentUrl);
+		if (parsed) onDeepLink(parsed);
+	};
+	window.addEventListener("popstate", handleUrlChange);
+	window.addEventListener("hashchange", handleUrlChange);
+	const initialData = parseDeepLink(window.location.href);
+	if (initialData && Object.keys(initialData.queryParams).length > 0) onDeepLink(initialData);
+	return () => {
+		window.removeEventListener("popstate", handleUrlChange);
+		window.removeEventListener("hashchange", handleUrlChange);
+	};
+}
+
+//#endregion
+//#region src/standard-events.ts
+/**
+* Predefined standard event name constants.
+*
+* Usage:
+* ```ts
+* import { StandardEvents } from '@layers/client';
+* client.track(StandardEvents.PURCHASE, { amount: 9.99, currency: 'USD' });
+* ```
+*/
+const StandardEvents = {
+	APP_OPEN: "app_open",
+	LOGIN: "login",
+	SIGN_UP: "sign_up",
+	REGISTER: "register",
+	PURCHASE: "purchase_success",
+	ADD_TO_CART: "add_to_cart",
+	ADD_TO_WISHLIST: "add_to_wishlist",
+	INITIATE_CHECKOUT: "initiate_checkout",
+	BEGIN_CHECKOUT: "begin_checkout",
+	START_TRIAL: "start_trial",
+	SUBSCRIBE: "subscribe",
+	LEVEL_START: "level_start",
+	LEVEL_COMPLETE: "level_complete",
+	TUTORIAL_COMPLETE: "tutorial_complete",
+	SEARCH: "search",
+	VIEW_ITEM: "view_item",
+	VIEW_CONTENT: "view_content",
+	SHARE: "share",
+	DEEP_LINK: "deep_link_opened",
+	SCREEN_VIEW: "screen_view"
+};
+/** Build a login event. */
+function loginEvent(method) {
+	const properties = {};
+	if (method !== void 0) properties.method = method;
+	return {
+		event: StandardEvents.LOGIN,
+		properties
+	};
+}
+/** Build a sign-up event. */
+function signUpEvent(method) {
+	const properties = {};
+	if (method !== void 0) properties.method = method;
+	return {
+		event: StandardEvents.SIGN_UP,
+		properties
+	};
+}
+/** Build a register event. */
+function registerEvent(method) {
+	const properties = {};
+	if (method !== void 0) properties.method = method;
+	return {
+		event: StandardEvents.REGISTER,
+		properties
+	};
+}
+/** Build a purchase event. */
+function purchaseEvent(amount, currency = "USD", itemId) {
+	const properties = {
+		amount,
+		currency
+	};
+	if (itemId !== void 0) properties.item_id = itemId;
+	return {
+		event: StandardEvents.PURCHASE,
+		properties
+	};
+}
+/** Build an add-to-cart event. */
+function addToCartEvent(itemId, price, quantity = 1) {
+	return {
+		event: StandardEvents.ADD_TO_CART,
+		properties: {
+			item_id: itemId,
+			price,
+			quantity
+		}
+	};
+}
+/** Build an add-to-wishlist event. */
+function addToWishlistEvent(itemId, name, price) {
+	const properties = { item_id: itemId };
+	if (name !== void 0) properties.name = name;
+	if (price !== void 0) properties.price = price;
+	return {
+		event: StandardEvents.ADD_TO_WISHLIST,
+		properties
+	};
+}
+/** Build an initiate-checkout event. */
+function initiateCheckoutEvent(value, currency = "USD", itemCount) {
+	const properties = {
+		value,
+		currency
+	};
+	if (itemCount !== void 0) properties.item_count = itemCount;
+	return {
+		event: StandardEvents.INITIATE_CHECKOUT,
+		properties
+	};
+}
+/** Build a start-trial event. */
+function startTrialEvent(plan, durationDays) {
+	const properties = {};
+	if (plan !== void 0) properties.plan = plan;
+	if (durationDays !== void 0) properties.duration_days = durationDays;
+	return {
+		event: StandardEvents.START_TRIAL,
+		properties
+	};
+}
+/** Build a subscribe event. */
+function subscribeEvent(plan, amount, currency = "USD") {
+	return {
+		event: StandardEvents.SUBSCRIBE,
+		properties: {
+			plan,
+			amount,
+			currency
+		}
+	};
+}
+/** Build a level-start event. */
+function levelStartEvent(level) {
+	return {
+		event: StandardEvents.LEVEL_START,
+		properties: { level }
+	};
+}
+/** Build a level-complete event. */
+function levelCompleteEvent(level, score) {
+	const properties = { level };
+	if (score !== void 0) properties.score = score;
+	return {
+		event: StandardEvents.LEVEL_COMPLETE,
+		properties
+	};
+}
+/** Build a tutorial-complete event. */
+function tutorialCompleteEvent(name) {
+	const properties = {};
+	if (name !== void 0) properties.name = name;
+	return {
+		event: StandardEvents.TUTORIAL_COMPLETE,
+		properties
+	};
+}
+/** Build a search event. */
+function searchEvent(query, resultCount) {
+	const properties = { query };
+	if (resultCount !== void 0) properties.result_count = resultCount;
+	return {
+		event: StandardEvents.SEARCH,
+		properties
+	};
+}
+/** Build a view-item event. */
+function viewItemEvent(itemId, name, category) {
+	const properties = { item_id: itemId };
+	if (name !== void 0) properties.name = name;
+	if (category !== void 0) properties.category = category;
+	return {
+		event: StandardEvents.VIEW_ITEM,
+		properties
+	};
+}
+/** Build a view-content event. */
+function viewContentEvent(contentId, contentType, name) {
+	const properties = { content_id: contentId };
+	if (contentType !== void 0) properties.content_type = contentType;
+	if (name !== void 0) properties.name = name;
+	return {
+		event: StandardEvents.VIEW_CONTENT,
+		properties
+	};
+}
+/** Build a share event. */
+function shareEvent(contentType, method, contentId) {
+	const properties = { content_type: contentType };
+	if (method !== void 0) properties.method = method;
+	if (contentId !== void 0) properties.content_id = contentId;
+	return {
+		event: StandardEvents.SHARE,
+		properties
+	};
+}
+/** Build a screen-view event. */
+function screenViewEvent(name, screenClass) {
+	const properties = { screen_name: name };
+	if (screenClass !== void 0) properties.screen_class = screenClass;
+	return {
+		event: StandardEvents.SCREEN_VIEW,
+		properties
+	};
+}
+
+//#endregion
+//#region src/commerce.ts
+/**
+* Track a successful purchase.
+*
+* ```ts
+* import { trackPurchase } from '@layers/client';
+*
+* trackPurchase(layers, {
+*   productId: 'premium_monthly',
+*   price: 9.99,
+*   currency: 'USD',
+*   transactionId: 'txn_abc123',
+* });
+* ```
+*/
+function trackPurchase(layers, params) {
+	const quantity = params.quantity ?? 1;
+	const props = {
+		product_id: params.productId,
+		price: params.price,
+		currency: params.currency,
+		quantity,
+		revenue: params.price * quantity,
+		...params.properties
+	};
+	if (params.transactionId !== void 0) props.transaction_id = params.transactionId;
+	if (params.isRestored !== void 0) props.is_restored = params.isRestored;
+	if (params.store !== void 0) props.store = params.store;
+	layers.track("purchase_success", props);
+}
+/**
+* Track a failed purchase attempt.
+*/
+function trackPurchaseFailed(layers, params) {
+	const props = {
+		product_id: params.productId,
+		currency: params.currency,
+		error_code: params.errorCode,
+		...params.properties
+	};
+	if (params.errorMessage !== void 0) props.error_message = params.errorMessage;
+	layers.track("purchase_failed", props);
+}
+/**
+* Track a subscription purchase or renewal.
+*
+* ```ts
+* import { trackSubscription } from '@layers/client';
+*
+* trackSubscription(layers, {
+*   productId: 'pro_annual',
+*   price: 49.99,
+*   currency: 'USD',
+*   period: 'P1Y',
+* });
+* ```
+*/
+function trackSubscription(layers, params) {
+	const props = {
+		product_id: params.productId,
+		price: params.price,
+		currency: params.currency,
+		quantity: 1,
+		revenue: params.price,
+		...params.properties
+	};
+	if (params.transactionId !== void 0) props.transaction_id = params.transactionId;
+	if (params.period !== void 0) props.period = params.period;
+	if (params.isRenewal !== void 0) props.is_renewal = params.isRenewal;
+	if (params.isTrial !== void 0) props.is_trial = params.isTrial;
+	if (params.subscriptionGroupId !== void 0) props.subscription_group_id = params.subscriptionGroupId;
+	if (params.originalTransactionId !== void 0) props.original_transaction_id = params.originalTransactionId;
+	layers.track("subscribe", props);
+}
+/**
+* Track a completed order with multiple line items.
+*/
+function trackOrder(layers, params) {
+	const currency = params.currency ?? "USD";
+	let total = params.subtotal;
+	if (params.tax !== void 0) total += params.tax;
+	if (params.shipping !== void 0) total += params.shipping;
+	if (params.discount !== void 0) total -= params.discount;
+	const props = {
+		order_id: params.orderId,
+		subtotal: params.subtotal,
+		total,
+		currency,
+		item_count: params.items.length,
+		revenue: total,
+		product_ids: params.items.map((i) => i.productId).join(","),
+		...params.properties
+	};
+	if (params.tax !== void 0) props.tax = params.tax;
+	if (params.shipping !== void 0) props.shipping = params.shipping;
+	if (params.discount !== void 0) props.discount = params.discount;
+	if (params.couponCode !== void 0) props.coupon_code = params.couponCode;
+	layers.track("purchase_success", props);
+}
+/**
+* Track an item being added to the cart.
+*/
+function trackAddToCart(layers, item, properties) {
+	const quantity = item.quantity ?? 1;
+	const props = {
+		product_id: item.productId,
+		product_name: item.name,
+		price: item.price,
+		quantity,
+		value: item.price * quantity,
+		...properties
+	};
+	if (item.category !== void 0) props.category = item.category;
+	layers.track("add_to_cart", props);
+}
+/**
+* Track an item being removed from the cart.
+*/
+function trackRemoveFromCart(layers, item, properties) {
+	const quantity = item.quantity ?? 1;
+	const props = {
+		product_id: item.productId,
+		product_name: item.name,
+		price: item.price,
+		quantity,
+		...properties
+	};
+	if (item.category !== void 0) props.category = item.category;
+	layers.track("remove_from_cart", props);
+}
+/**
+* Track beginning the checkout flow.
+*/
+function trackBeginCheckout(layers, items, currency = "USD", properties) {
+	const total = items.reduce((sum, item) => sum + item.price * (item.quantity ?? 1), 0);
+	const props = {
+		item_count: items.length,
+		value: total,
+		currency,
+		product_ids: items.map((i) => i.productId).join(","),
+		...properties
+	};
+	layers.track("begin_checkout", props);
+}
+/**
+* Track viewing a product detail page.
+*/
+function trackViewProduct(layers, productId, name, price, currency = "USD", category, properties) {
+	const props = {
+		product_id: productId,
+		product_name: name,
+		price,
+		currency,
+		...properties
+	};
+	if (category !== void 0) props.category = category;
+	layers.track("view_item", props);
+}
+/**
+* Track a refund.
+*/
+function trackRefund(layers, params) {
+	const props = {
+		transaction_id: params.transactionId,
+		amount: params.amount,
+		currency: params.currency,
+		...params.properties
+	};
+	if (params.reason !== void 0) props.reason = params.reason;
+	layers.track("refund", props);
+}
+
+//#endregion
+//#region src/index.ts
+const INSTALL_ID_KEY = "layers_install_id";
+const FIRST_LAUNCH_TRACKED_KEY = "layers_first_launch_tracked";
+const FIRST_INSTALL_TIME_KEY = "layers_first_install_time";
+const CLIPBOARD_CHECKED_KEY = "layers_clipboard_checked";
+const ATTRIBUTION_DATA_KEY = "layers_attribution_data";
+/** Maximum age of an installation for install event gating (24 hours). */
+const INSTALL_EVENT_MAX_DIFF_MS = 1440 * 60 * 1e3;
+var LayersClient = class LayersClient {
+	core;
+	appUserId;
+	isOnline = true;
+	enableDebug;
+	baseUrl;
+	config;
+	onlineListener = null;
+	offlineListener = null;
+	visibilityListener = null;
+	beforeUnloadListener = null;
+	deepLinkUnsubscribe = null;
+	errorListeners = /* @__PURE__ */ new Set();
+	_installId = null;
+	_hadPriorSdkState = false;
+	_attributionData = null;
+	static MAX_RECENT_EVENTS = 20;
+	_recentEvents = [];
+	_isInitialized = false;
+	_initListener = null;
+	_debugOverlayActive = false;
+	constructor(config) {
+		this.enableDebug = config.enableDebug ?? false;
+		this.baseUrl = (config.baseUrl ?? "https://in.layers.com").replace(/\/$/, "");
+		this.appUserId = config.appUserId;
+		this.config = config;
+		const persistence = createDefaultPersistence(config.appId);
+		const httpClient = new FetchHttpClient();
+		this.core = LayersCore.init({
+			config: {
+				appId: config.appId,
+				environment: config.environment ?? "production",
+				...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() {
+		const initStartTime = typeof performance !== "undefined" ? performance.now() : Date.now();
+		this.initializeInstallId();
+		this.initializeDeviceInfo();
+		this.setupNetworkListener();
+		this.setupLifecycleListeners();
+		captureAttribution();
+		this.restoreAttributionData();
+		const mainThreadEndTime = typeof performance !== "undefined" ? performance.now() : Date.now();
+		const mainThreadDurationMs = Math.round(mainThreadEndTime - initStartTime);
+		await this.core.fetchRemoteConfig().catch(() => {});
+		this.checkClipboardAttribution();
+		if (this.config.autoTrackAppOpen !== false) {
+			const appOpenProps = {};
+			const isFirstLaunch = this.shouldTreatAsNewInstall();
+			appOpenProps.is_first_launch = isFirstLaunch;
+			if (isFirstLaunch) this.storageSet(FIRST_LAUNCH_TRACKED_KEY, "true");
+			this.track("app_open", appOpenProps);
+		}
+		if (this.config.autoTrackDeepLinks !== false) this.setupDeepLinkAutoTracking();
+		this._isInitialized = true;
+		const totalEndTime = typeof performance !== "undefined" ? performance.now() : Date.now();
+		const totalDurationMs = Math.round(totalEndTime - initStartTime);
+		this.trackInitTiming(mainThreadDurationMs, totalDurationMs);
+		if (this.enableDebug) console.log(`[Layers] Init timing: mainThread=${String(mainThreadDurationMs)}ms, total=${String(totalDurationMs)}ms`);
+		if (this._initListener) try {
+			this._initListener(mainThreadDurationMs, totalDurationMs);
+		} catch (e) {
+			if (this.enableDebug) console.warn("[Layers] InitListener threw:", e);
+		}
+	}
+	/**
+	* 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 = this.mergeAllProperties(properties);
+			const depthBefore = this.core.queueDepth();
+			this.core.track(eventName, merged, this.appUserId);
+			const depthAfter = this.core.queueDepth();
+			if (depthAfter <= depthBefore && this.enableDebug) console.warn(`[Layers] track("${eventName}") — event may not have been queued (depth before=${String(depthBefore)}, after=${String(depthAfter)})`);
+			this.recordRecentEvent(eventName, properties);
+		} 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 = this.mergeAllProperties(properties);
+			const depthBefore = this.core.queueDepth();
+			this.core.screen(screenName, merged, this.appUserId);
+			const depthAfter = this.core.queueDepth();
+			if (depthAfter <= depthBefore && this.enableDebug) console.warn(`[Layers] screen("${screenName}") — event may not have been queued (depth before=${String(depthBefore)}, after=${String(depthAfter)})`);
+			this.recordRecentEvent(`screen:${screenName}`, properties);
+		} catch (e) {
+			this.emitError(e);
+		}
+	}
+	/** Set or update user-level properties that persist across sessions. */
+	setUserProperties(properties) {
+		this.core.setUserProperties(properties);
+	}
+	/** Set user-level properties with "set once" semantics — only keys not previously set are applied. */
+	setUserPropertiesOnce(properties) {
+		this.core.setUserPropertiesOnce(properties);
+	}
+	/** Update the user's consent state for analytics and advertising data collection. */
+	setConsent(consent) {
+		this.core.setConsent(consent);
+	}
+	/**
+	* Associate all subsequent events with a group (company, team, organization).
+	* Pass `undefined` or empty string to clear the group association.
+	*/
+	group(groupId, properties) {
+		if (this.enableDebug) console.log(`[Layers] group(${groupId ? `"${groupId}"` : "undefined"}, ${Object.keys(properties ?? {}).length} properties)`);
+		try {
+			this.core.group(groupId ?? "", properties);
+		} catch (e) {
+			this.emitError(e);
+		}
+	}
+	/** 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);
+	}
+	/**
+	* Return the install ID (persistent UUID stored in localStorage).
+	* Generated on first init, persists across sessions.
+	*/
+	getInstallId() {
+		return this._installId;
+	}
+	/**
+	* Return the number of events currently queued.
+	*/
+	getQueueDepth() {
+		return this.core.queueDepth();
+	}
+	/**
+	* Store attribution data that will be attached to all subsequent events.
+	*
+	* The values are persisted in localStorage so they survive page reloads.
+	* Pass `null` to clear a value.
+	*
+	* When set, `deeplinkId`, `gclid`, `fbclid`, `ttclid`, and/or `msclkid`
+	* are included in every event's properties.
+	*/
+	setAttributionData(data) {
+		this._attributionData = data;
+		try {
+			const ctx = { ...this.core.getDeviceContext() };
+			if (data.deeplinkId) ctx.deeplinkId = data.deeplinkId;
+			else delete ctx.deeplinkId;
+			this.core.setDeviceContext(ctx);
+		} catch {}
+		try {
+			if (typeof localStorage !== "undefined") localStorage.setItem(ATTRIBUTION_DATA_KEY, JSON.stringify(data));
+		} catch {}
+		if (this.enableDebug) console.log(`[Layers] setAttributionData(${JSON.stringify(data)})`);
+	}
+	/**
+	* Set a listener to receive SDK initialization timing metrics.
+	* Must be called **before** `init()` to receive the callback.
+	* Pass `null` to clear the listener.
+	*/
+	setInitListener(listener) {
+		this._initListener = listener;
+	}
+	/**
+	* Enable the debug overlay — a lightweight DOM panel showing SDK state.
+	* The overlay updates every second with queue depth, session info, and recent events.
+	*/
+	enableDebugOverlay() {
+		this._debugOverlayActive = true;
+		enableDebugOverlay(() => ({
+			sdkVersion: SDK_VERSION,
+			queueDepth: this.core.queueDepth(),
+			sessionId: this.core.getSessionId(),
+			installId: this._installId,
+			appId: this.config.appId,
+			environment: this.config.environment ?? "production",
+			isOnline: this.isOnline,
+			recentEvents: this._recentEvents
+		}));
+	}
+	/**
+	* Disable and remove the debug overlay from the DOM.
+	*/
+	disableDebugOverlay() {
+		this._debugOverlayActive = false;
+		disableDebugOverlay();
+	}
+	/** Whether the SDK has completed async initialization. */
+	get isInitialized() {
+		return this._isInitialized;
+	}
+	/** SDK version string. */
+	getSdkVersion() {
+		return SDK_VERSION;
+	}
+	/**
+	* Returns the most recent tracked events (newest first).
+	* Each entry is a formatted string like "12:34:56 event_name (3 props)".
+	*/
+	getRecentEvents() {
+		return this._recentEvents;
+	}
+	/** 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();
+		if (this._debugOverlayActive) this.disableDebugOverlay();
+		this._attributionData = null;
+		this._initListener = null;
+		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();
+		if (this._debugOverlayActive) this.disableDebugOverlay();
+		this._attributionData = null;
+		this._initListener = null;
+		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;
+		}
+		if (this.deepLinkUnsubscribe) {
+			this.deepLinkUnsubscribe();
+			this.deepLinkUnsubscribe = 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);
+	}
+	initializeInstallId() {
+		if (typeof localStorage === "undefined") return;
+		try {
+			const existing = localStorage.getItem(INSTALL_ID_KEY);
+			if (existing) {
+				this._installId = existing;
+				this._hadPriorSdkState = true;
+			} else {
+				const newId = generateUUID();
+				localStorage.setItem(INSTALL_ID_KEY, newId);
+				this._installId = newId;
+				this._hadPriorSdkState = false;
+				if (!localStorage.getItem(FIRST_INSTALL_TIME_KEY)) localStorage.setItem(FIRST_INSTALL_TIME_KEY, String(Date.now()));
+			}
+		} catch {
+			this._installId = generateUUID();
+		}
+	}
+	shouldTreatAsNewInstall() {
+		if (this.storageGet(FIRST_LAUNCH_TRACKED_KEY) === "true") return false;
+		if (this._hadPriorSdkState) return true;
+		const installTimeStr = this.storageGet(FIRST_INSTALL_TIME_KEY);
+		if (installTimeStr) {
+			const installTime = Number(installTimeStr);
+			if (Number.isFinite(installTime)) {
+				const elapsed = Date.now() - installTime;
+				const isRecentInstall = elapsed <= INSTALL_EVENT_MAX_DIFF_MS;
+				if (!isRecentInstall && this.enableDebug) console.log(`[Layers] Install event gated: installed ${Math.round(elapsed / 1e3)}s ago (threshold=${INSTALL_EVENT_MAX_DIFF_MS / 1e3}s), no prior SDK state — suppressing is_first_launch`);
+				return isRecentInstall;
+			}
+		}
+		return true;
+	}
+	restoreAttributionData() {
+		try {
+			if (typeof localStorage === "undefined") return;
+			const raw = localStorage.getItem(ATTRIBUTION_DATA_KEY);
+			if (!raw) return;
+			const data = JSON.parse(raw);
+			this._attributionData = data;
+			if (data.deeplinkId) try {
+				const currentContext = this.core.getDeviceContext();
+				this.core.setDeviceContext({
+					...currentContext,
+					deeplinkId: data.deeplinkId
+				});
+			} catch {}
+			if (this.enableDebug && data) console.log(`[Layers] Restored attribution data: ${JSON.stringify(data)}`);
+		} catch {}
+	}
+	/**
+	* Merge attribution properties into event properties.
+	* deeplink_id flows through DeviceContext; other fields flow through properties.
+	*/
+	mergeAttributionProperties(properties) {
+		const data = this._attributionData;
+		if (!data) return properties;
+		const merged = { ...properties ?? {} };
+		if (data.gclid) merged.gclid = data.gclid;
+		if (data.fbclid) merged.fbclid = data.fbclid;
+		if (data.ttclid) merged.ttclid = data.ttclid;
+		if (data.msclkid) merged.msclkid = data.msclkid;
+		return merged;
+	}
+	/** Merge CAPI, attribution (url-based), setAttributionData, and user properties. */
+	mergeAllProperties(properties) {
+		const capiProps = getCapiProperties();
+		const urlAttrProps = getAttributionProperties();
+		const attrProps = this.mergeAttributionProperties(void 0) ?? {};
+		return {
+			...capiProps,
+			...urlAttrProps,
+			...attrProps,
+			...properties
+		};
+	}
+	checkClipboardAttribution() {
+		if (typeof navigator === "undefined" || typeof localStorage === "undefined") return;
+		try {
+			if (localStorage.getItem(CLIPBOARD_CHECKED_KEY) === "true") return;
+		} catch {
+			return;
+		}
+		let clipboardEnabled = false;
+		try {
+			const configJson = this.core.getRemoteConfigJson?.();
+			if (configJson) clipboardEnabled = JSON.parse(configJson)?.clipboard_attribution_enabled === true;
+		} catch {}
+		this.storageSet(CLIPBOARD_CHECKED_KEY, "true");
+		if (!clipboardEnabled) return;
+		if (navigator.clipboard?.readText) navigator.clipboard.readText().then((text) => {
+			if (!text) return;
+			const match = text.match(/https?:\/\/(in\.layers\.com|link\.layers\.com)\/c\/([^?\s]+)/);
+			if (match) {
+				this.track("clipboard_attribution", {
+					clipboard_url: text,
+					clipboard_click_id: match[2]
+				});
+				if (this.enableDebug) console.log(`[Layers] Clipboard attribution found: ${match[2]}`);
+			}
+		}).catch(() => {});
+	}
+	_trackedDeepLinkUrls = /* @__PURE__ */ new Set();
+	setupDeepLinkAutoTracking() {
+		this.deepLinkUnsubscribe = setupDeepLinkListener((data) => {
+			if (this._trackedDeepLinkUrls.has(data.url)) return;
+			this._trackedDeepLinkUrls.add(data.url);
+			setTimeout(() => this._trackedDeepLinkUrls.delete(data.url), 2e3);
+			try {
+				const properties = {
+					...data.queryParams,
+					url: data.url,
+					scheme: data.scheme,
+					host: data.host,
+					path: data.path
+				};
+				this.track("deep_link_opened", properties);
+				if (this.enableDebug) console.log(`[Layers] auto-tracked deep_link_opened: ${data.url}`);
+			} catch (e) {
+				this.emitError(e);
+			}
+		});
+	}
+	trackInitTiming(mainThreadDurationMs, totalDurationMs) {
+		try {
+			this.core.track("layers_init_timing", {
+				duration_ms: totalDurationMs,
+				main_thread_duration_ms: mainThreadDurationMs
+			}, this.appUserId);
+		} catch {}
+	}
+	recordRecentEvent(eventName, properties) {
+		const now = /* @__PURE__ */ new Date();
+		const time = `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}`;
+		const propCount = Object.keys(properties ?? {}).length;
+		const entry = `${time} ${eventName}${propCount > 0 ? ` (${String(propCount)} props)` : ""}`;
+		this._recentEvents.unshift(entry);
+		if (this._recentEvents.length > LayersClient.MAX_RECENT_EVENTS) this._recentEvents.pop();
+	}
+	initializeDeviceInfo() {
+		const context = {
+			platform: "web",
+			osVersion: this.detectOS(),
+			appVersion: SDK_VERSION,
+			deviceModel: this.detectDeviceModel(),
+			locale: this.detectLocale(),
+			screenSize: this.detectScreenSize(),
+			timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+			...this._installId != null && { installId: this._installId }
+		};
+		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") {
+				try {
+					this.core.track("app_background", {}, this.appUserId);
+					this.recordRecentEvent("app_background");
+				} catch {}
+				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();
+			} else if (document.visibilityState === "visible") {
+				try {
+					this.core.track("app_foreground", {}, this.appUserId);
+					this.recordRecentEvent("app_foreground");
+				} catch {}
+				if (this.isOnline) this.core.flushAsync().catch(() => {});
+			}
+		};
+		document.addEventListener("visibilitychange", this.visibilityListener);
+		this.beforeUnloadListener = () => {
+			this.core.flush();
+		};
+		window.addEventListener("beforeunload", this.beforeUnloadListener);
+	}
+	storageGet(key) {
+		if (typeof localStorage === "undefined") return null;
+		try {
+			return localStorage.getItem(key);
+		} catch {
+			return null;
+		}
+	}
+	storageSet(key, value) {
+		if (typeof localStorage === "undefined") return;
+		try {
+			localStorage.setItem(key, value);
+		} catch {}
+	}
+};
+function generateUUID() {
+	if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID();
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+		const r = Math.floor(Math.random() * 16);
+		return (c === "x" ? r : r % 4 + 8).toString(16);
+	});
+}
+const SDK_VERSION = typeof __LAYERS_CLIENT_VERSION__ !== "undefined" ? __LAYERS_CLIENT_VERSION__ : "0.1.1-alpha.1";
+
+//#endregion
+export { parseDeepLink as A, shareEvent as C, tutorialCompleteEvent as D, subscribeEvent as E, getFbpCookie as F, getPageUrl as I, getTtpCookie as L, formatFbc as M, getCapiProperties as N, viewContentEvent as O, getFbc as P, getAttribution as R, searchEvent as S, startTrialEvent as T, levelStartEvent as _, trackOrder as a, registerEvent as b, trackRefund as c, trackViewProduct as d, StandardEvents as f, levelCompleteEvent as g, initiateCheckoutEvent as h, trackBeginCheckout as i, setupDeepLinkListener as j, viewItemEvent as k, trackRemoveFromCart as l, addToWishlistEvent as m, LayersError$1 as n, trackPurchase as o, addToCartEvent as p, trackAddToCart as r, trackPurchaseFailed as s, LayersClient as t, trackSubscription as u, loginEvent as v, signUpEvent as w, screenViewEvent as x, purchaseEvent as y, getAttributionProperties as z };
+//# sourceMappingURL=src-DnOWq7k2.js.map