@layers/client 0.1.1-alpha.1 → 1.0.1

package/dist/index.js

@@ -1,617 +1,3 @@
-//#region src/index.ts
-const SDK_VERSION = "0.0.0";
-const DEFAULT_BASE_URL = "https://in.layers.com";
-const SYSTEM_EVENTS = new Set(["consent_updated", "att_status_changed"]);
-const DEFAULT_CONSENT = {
-	advertising: true,
-	analytics: true
-};
-const DEFAULT_QUEUE_CONFIG = {
-	flushIntervalMs: 1e4,
-	maxQueueSize: 200,
-	maxItemAgeMs: 5 * 6e4,
-	requestTimeoutMs: 1e4,
-	maxRetries: 5,
-	baseRetryDelayMs: 1e3,
-	maxRetryDelayMs: 3e4
-};
-function now() {
-	return Date.now();
-}
-function generateId(prefix) {
-	return `${prefix}_${Math.random().toString(36).slice(2)}_${now()}`;
-}
-var LayersClient = class {
-	config;
-	remoteConfig = null;
-	remoteConfigMeta = {};
-	eventQueue = [];
-	isOnline = true;
-	consentState = { ...DEFAULT_CONSENT };
-	sessionId;
-	deviceInfo = {};
-	queueTimer = null;
-	queueConfig;
-	queueStorage;
-	rateLimitState = {
-		global: {},
-		perEvent: /* @__PURE__ */ new Map()
-	};
-	logLevel() {
-		if (typeof process !== "undefined" && process.env?.LOG_LEVEL) return process.env.LOG_LEVEL.toLowerCase();
-		if (this.config.enableDebug) return "debug";
-		return "info";
-	}
-	shouldLog(level) {
-		const currentLevel = this.logLevel();
-		const levels = [
-			"error",
-			"warn",
-			"info",
-			"debug",
-			"trace"
-		];
-		return levels.indexOf(currentLevel) >= levels.indexOf(level);
-	}
-	constructor(config) {
-		this.queueConfig = {
-			...DEFAULT_QUEUE_CONFIG,
-			...config.queueOptions || {}
-		};
-		this.queueStorage = config.queueStorage ?? createDefaultQueueStorage(config.appId);
-		const resolvedAppUserId = config.appUserId;
-		this.config = {
-			...config,
-			baseUrl: (config.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, ""),
-			appUserId: resolvedAppUserId
-		};
-		this.sessionId = this.generateSessionId();
-		this.resetRateLimitState();
-		this.initializeDeviceInfo();
-	}
-	generateSessionId() {
-		return generateId("sess");
-	}
-	initializeDeviceInfo() {
-		this.deviceInfo = {
-			platform: "react-native",
-			os_version: "unknown",
-			app_version: "unknown",
-			locale: "en-US",
-			device_model: "unknown"
-		};
-	}
-	async init() {
-		await this.hydrateQueue();
-		await this.fetchRemoteConfig();
-		this.setupNetworkListener();
-		this.scheduleQueueFlush(this.eventQueue.length > 0);
-	}
-	async fetchRemoteConfig(force = false) {
-		const expired = !this.remoteConfigMeta.expiresAt || this.remoteConfigMeta.expiresAt < now();
-		if (!force && this.remoteConfig && !expired) return;
-		try {
-			const response = await this.makeRequest("/config", { method: "GET" });
-			if (!response?.config) return;
-			this.remoteConfig = response.config;
-			const ttlMs = (response.cache_ttl ?? 300) * 1e3;
-			this.remoteConfigMeta = {
-				version: response.version,
-				expiresAt: now() + ttlMs,
-				...this.extractRemoteConfigSettings(response)
-			};
-			this.resetRateLimitState();
-		} catch (error) {
-			if (this.shouldLog("debug")) console.warn("[Layers] Failed to fetch remote config:", error);
-		}
-	}
-	extractRemoteConfigSettings(envelope) {
-		const meta = {};
-		const config = envelope.config ?? {};
-		if (config.privacy) {
-			if (typeof config.privacy.analytics_enabled === "boolean") meta.analyticsEnabled = config.privacy.analytics_enabled;
-			if (typeof config.privacy.advertising_enabled === "boolean") meta.advertisingEnabled = config.privacy.advertising_enabled;
-			if (config.privacy.killswitches) {
-				const killswitches = new Set(config.privacy.killswitches);
-				if (killswitches.has("analytics")) meta.analyticsEnabled = false;
-				if (killswitches.has("advertising")) meta.advertisingEnabled = false;
-			}
-		}
-		if (config.events) {
-			if (Array.isArray(config.events.allowlist)) meta.eventAllowlist = new Set(config.events.allowlist);
-			if (Array.isArray(config.events.denylist)) meta.eventDenylist = new Set(config.events.denylist);
-			const samplingEntries = {};
-			if (config.events.sampling) for (const [eventName, value] of Object.entries(config.events.sampling)) {
-				const numeric = Number(value);
-				if (Number.isFinite(numeric)) samplingEntries[eventName] = Math.max(0, Math.min(1, numeric));
-			}
-			if (typeof config.events.sampling_rate === "number") samplingEntries["*"] = Math.max(0, Math.min(1, config.events.sampling_rate));
-			if (Object.keys(samplingEntries).length > 0) meta.samplingRates = samplingEntries;
-			const rateLimitConfig = config.events.rate_limit;
-			if (rateLimitConfig) {
-				const globalRule = this.normalizeRateLimitRule(rateLimitConfig);
-				let perEventRules;
-				if (rateLimitConfig.per_event) {
-					const entries = Object.entries(rateLimitConfig.per_event);
-					if (entries.length > 0) {
-						perEventRules = /* @__PURE__ */ new Map();
-						for (const [eventName, ruleConfig] of entries) {
-							const rule = this.normalizeRateLimitRule(ruleConfig);
-							if (rule) perEventRules.set(eventName, rule);
-						}
-						if (perEventRules.size === 0) perEventRules = void 0;
-					}
-				}
-				const rateLimits = {};
-				if (globalRule) rateLimits.global = globalRule;
-				if (perEventRules) rateLimits.perEvent = perEventRules;
-				if (rateLimits.global || rateLimits.perEvent) meta.rateLimits = rateLimits;
-			}
-		}
-		return meta;
-	}
-	setupNetworkListener() {
-		if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
-			window.addEventListener("online", () => {
-				this.setOnlineState(true);
-			});
-			window.addEventListener("offline", () => {
-				this.setOnlineState(false);
-			});
-		}
-	}
-	setOnlineState(isOnline) {
-		if (this.isOnline === isOnline) return;
-		this.isOnline = isOnline;
-		if (isOnline) this.scheduleQueueFlush(true);
-	}
-	async hydrateQueue() {
-		if (!this.queueStorage) return;
-		try {
-			const snapshot = await this.queueStorage.load();
-			if (!snapshot || !Array.isArray(snapshot.items) || snapshot.items.length === 0) {
-				if (snapshot) await this.queueStorage.clear();
-				return;
-			}
-			const nowTs = now();
-			const maxAge = this.queueConfig.maxItemAgeMs;
-			const hydrated = [];
-			for (const item of snapshot.items) if (item && typeof item.endpoint === "string") {
-				const queuedAt = typeof item.queuedAt === "number" ? item.queuedAt : nowTs;
-				if (nowTs - queuedAt <= maxAge) hydrated.push({
-					endpoint: item.endpoint,
-					data: item.data,
-					attempts: typeof item.attempts === "number" ? item.attempts : 0,
-					queuedAt,
-					nextAttemptAt: typeof item.nextAttemptAt === "number" ? item.nextAttemptAt : nowTs,
-					requestId: typeof item.requestId === "string" ? item.requestId : generateId("req"),
-					retryable: item.retryable !== false
-				});
-			}
-			if (hydrated.length === 0) {
-				await this.queueStorage.clear();
-				this.eventQueue = [];
-				return;
-			}
-			const limited = hydrated.slice(0, this.queueConfig.maxQueueSize);
-			const trimmed = limited.length !== hydrated.length;
-			this.eventQueue = limited;
-			if (trimmed || limited.length !== snapshot.items.length) await this.persistQueue();
-		} catch (error) {
-			if (this.shouldLog("debug")) console.warn("[Layers] Failed to hydrate queue", error);
-		}
-	}
-	async persistQueue() {
-		if (!this.queueStorage) return;
-		const snapshot = {
-			version: 1,
-			items: this.eventQueue.map((item) => ({
-				endpoint: item.endpoint,
-				data: item.data,
-				attempts: item.attempts,
-				queuedAt: item.queuedAt,
-				nextAttemptAt: item.nextAttemptAt,
-				requestId: item.requestId,
-				retryable: item.retryable
-			}))
-		};
-		try {
-			if (snapshot.items.length === 0) await this.queueStorage.clear();
-			else await this.queueStorage.save(snapshot);
-		} catch (error) {
-			if (this.shouldLog("debug")) console.warn("[Layers] Failed to persist queue", error);
-		}
-	}
-	async track(eventName, properties) {
-		if (!this.shouldProcessEvent(eventName)) {
-			if (this.shouldLog("debug")) console.log(`[Layers] Event '${eventName}' dropped due to consent or config gating`);
-			return;
-		}
-		if (!this.passesSampling(eventName)) {
-			if (this.shouldLog("debug")) console.log(`[Layers] Event '${eventName}' sampled out`);
-			return;
-		}
-		const batchPayload = {
-			events: [{
-				event: eventName,
-				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-				event_id: this.generateEventId(),
-				app_id: this.config.appId,
-				session_id: this.sessionId,
-				environment: this.config.environment,
-				platform: this.deviceInfo.platform,
-				os_version: this.deviceInfo.os_version,
-				app_version: this.deviceInfo.app_version,
-				device_model: this.deviceInfo.device_model,
-				locale: this.deviceInfo.locale,
-				...this.deviceInfo,
-				properties: properties || {},
-				...this.resolveAppUserId() && { app_user_id: this.resolveAppUserId() }
-			}],
-			batch_id: this.generateBatchId(),
-			sent_at: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		const appUserId = this.resolveAppUserId();
-		console.log(`[Layers] Tracking event: ${eventName}${appUserId ? ` (user: ${appUserId})` : " (no user)"}`);
-		await this.enqueue("/events", batchPayload);
-	}
-	shouldProcessEvent(eventName) {
-		if (SYSTEM_EVENTS.has(eventName)) return true;
-		if (!this.isAnalyticsEnabled()) return false;
-		if (this.remoteConfigMeta.eventAllowlist && !this.remoteConfigMeta.eventAllowlist.has(eventName)) return false;
-		if (this.remoteConfigMeta.eventDenylist && this.remoteConfigMeta.eventDenylist.has(eventName)) return false;
-		if (!this.passesRateLimit(eventName)) return false;
-		return true;
-	}
-	passesSampling(eventName) {
-		const sampling = this.remoteConfigMeta.samplingRates;
-		if (!sampling) return true;
-		const rate = sampling[eventName] ?? sampling["*"];
-		if (typeof rate !== "number") return true;
-		return Math.random() <= Math.max(0, Math.min(1, rate));
-	}
-	resolveAppUserId() {
-		return this.config.appUserId;
-	}
-	async screen(screenName, properties) {
-		await this.track("screen_view", {
-			screen_name: screenName,
-			...properties
-		});
-	}
-	async setUserProperties(properties) {
-		if (!this.isAnalyticsEnabled()) return;
-		const payload = {
-			app_id: this.config.appId,
-			properties,
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			...this.resolveAppUserId() && { app_user_id: this.resolveAppUserId() }
-		};
-		await this.enqueue("/users/properties", payload);
-	}
-	isAnalyticsEnabled() {
-		if (this.remoteConfigMeta.analyticsEnabled === false) return false;
-		return this.consentState.analytics !== false;
-	}
-	isAdvertisingEnabled() {
-		if (this.remoteConfigMeta.advertisingEnabled === false) return false;
-		return this.consentState.advertising !== false;
-	}
-	async setConsent(consent) {
-		this.consentState = {
-			advertising: typeof consent.advertising === "boolean" ? consent.advertising : this.consentState.advertising,
-			analytics: typeof consent.analytics === "boolean" ? consent.analytics : this.consentState.analytics
-		};
-		const payload = {
-			app_id: this.config.appId,
-			consent: { ...this.consentState },
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			...this.resolveAppUserId() && { app_user_id: this.resolveAppUserId() }
-		};
-		await this.enqueue("/consent", payload);
-	}
-	async enqueue(endpoint, data, options) {
-		const retryable = options?.retryable !== false;
-		if (this.eventQueue.length >= this.queueConfig.maxQueueSize) this.eventQueue.shift();
-		this.eventQueue.push({
-			endpoint,
-			data,
-			attempts: 0,
-			queuedAt: now(),
-			nextAttemptAt: now(),
-			requestId: generateId("req"),
-			retryable
-		});
-		if (this.isOnline) this.scheduleQueueFlush(true);
-		else this.scheduleQueueFlush();
-		this.persistQueue();
-	}
-	scheduleQueueFlush(immediate = false) {
-		if (this.queueTimer) {
-			clearTimeout(this.queueTimer);
-			this.queueTimer = null;
-		}
-		const delay = immediate ? 0 : this.queueConfig.flushIntervalMs;
-		this.queueTimer = setTimeout(() => {
-			this.queueTimer = null;
-			this.processQueue();
-		}, delay);
-	}
-	async processQueue() {
-		if (!this.isOnline || this.eventQueue.length === 0) {
-			this.scheduleQueueFlush();
-			return;
-		}
-		this.dropExpiredQueueItems();
-		const pending = [];
-		for (const item of this.eventQueue) if (item.nextAttemptAt > now()) pending.push(item);
-		else {
-			let shouldRequeue = false;
-			try {
-				await this.makeRequest(item.endpoint, {
-					method: "POST",
-					body: JSON.stringify(item.data)
-				}, item.requestId);
-			} catch (err) {
-				if (!item.retryable) {
-					if (this.shouldLog("debug")) console.warn("[Layers] Dropping non-retryable item", {
-						endpoint: item.endpoint,
-						error: err
-					});
-				} else {
-					item.attempts += 1;
-					if (item.attempts > this.queueConfig.maxRetries) {
-						if (this.shouldLog("debug")) console.warn("[Layers] Dropping item after max retries", {
-							endpoint: item.endpoint,
-							error: err
-						});
-					} else {
-						item.nextAttemptAt = now() + this.getBackoffDelay(item.attempts);
-						shouldRequeue = true;
-						if (this.shouldLog("debug")) console.warn("[Layers] Retry scheduled", {
-							endpoint: item.endpoint,
-							nextAttemptAt: item.nextAttemptAt,
-							error: err
-						});
-					}
-				}
-			}
-			if (shouldRequeue) pending.push(item);
-		}
-		this.eventQueue = pending;
-		await this.persistQueue();
-		this.scheduleQueueFlush(this.eventQueue.length > 0);
-	}
-	dropExpiredQueueItems() {
-		const cutoff = now() - this.queueConfig.maxItemAgeMs;
-		if (this.eventQueue.length === 0) return;
-		const retained = this.eventQueue.filter((item) => item.queuedAt >= cutoff);
-		if (this.shouldLog("debug") && retained.length !== this.eventQueue.length) console.warn("[Layers] Dropped stale queue items", { dropped: this.eventQueue.length - retained.length });
-		this.eventQueue = retained;
-		this.persistQueue();
-	}
-	getBackoffDelay(attempt) {
-		const jitter = Math.random() * 250;
-		const delay = this.queueConfig.baseRetryDelayMs * 2 ** (attempt - 1);
-		return Math.min(delay + jitter, this.queueConfig.maxRetryDelayMs);
-	}
-	resetRateLimitState() {
-		this.rateLimitState = {
-			global: {},
-			perEvent: /* @__PURE__ */ new Map()
-		};
-	}
-	getEventRateCounter(eventName) {
-		let counter = this.rateLimitState.perEvent.get(eventName);
-		if (!counter) {
-			counter = {};
-			this.rateLimitState.perEvent.set(eventName, counter);
-		}
-		return counter;
-	}
-	normalizeRateLimitRule(input) {
-		if (!input) return;
-		const rule = {};
-		if (typeof input.per_minute === "number" && input.per_minute > 0) rule.perMinute = Math.floor(input.per_minute);
-		if (typeof input.per_hour === "number" && input.per_hour > 0) rule.perHour = Math.floor(input.per_hour);
-		return Object.keys(rule).length > 0 ? rule : void 0;
-	}
-	passesRateLimit(eventName) {
-		if (SYSTEM_EVENTS.has(eventName)) return true;
-		const { rateLimits } = this.remoteConfigMeta;
-		if (!rateLimits) return true;
-		const timestamp = now();
-		const perEventRules = rateLimits.perEvent;
-		const eventRule = perEventRules?.get(eventName) ?? perEventRules?.get("*");
-		if (eventRule && !this.canConsumeRateLimit(eventRule, this.getEventRateCounter(eventName), timestamp)) {
-			if (this.shouldLog("debug")) console.warn("[Layers] Rate limit reached for event", { event: eventName });
-			return false;
-		}
-		if (rateLimits.global && !this.canConsumeRateLimit(rateLimits.global, this.rateLimitState.global, timestamp)) {
-			if (this.shouldLog("debug")) console.warn("[Layers] Global rate limit reached", { event: eventName });
-			return false;
-		}
-		if (eventRule) this.recordRateLimit(eventRule, this.getEventRateCounter(eventName), timestamp);
-		if (rateLimits.global) this.recordRateLimit(rateLimits.global, this.rateLimitState.global, timestamp);
-		return true;
-	}
-	canConsumeRateLimit(rule, counter, timestamp) {
-		return this.canConsumeWindow(rule.perMinute, counter, "perMinute", 6e4, timestamp) && this.canConsumeWindow(rule.perHour, counter, "perHour", 36e5, timestamp);
-	}
-	canConsumeWindow(limit, counter, key, windowMs, timestamp) {
-		if (limit === void 0) return true;
-		const { count } = this.getWindowInfo(counter, key, windowMs, timestamp);
-		return count + 1 <= limit;
-	}
-	recordRateLimit(rule, counter, timestamp) {
-		this.incrementWindow(rule.perMinute, counter, "perMinute", 6e4, timestamp);
-		this.incrementWindow(rule.perHour, counter, "perHour", 36e5, timestamp);
-	}
-	incrementWindow(limit, counter, key, windowMs, timestamp) {
-		if (limit === void 0) return;
-		const windowStart = Math.floor(timestamp / windowMs) * windowMs;
-		const existing = counter[key];
-		if (!existing || existing.windowStart !== windowStart) counter[key] = {
-			windowStart,
-			count: 1
-		};
-		else existing.count += 1;
-	}
-	getWindowInfo(counter, key, windowMs, timestamp) {
-		const windowStart = Math.floor(timestamp / windowMs) * windowMs;
-		const existing = counter[key];
-		if (!existing || existing.windowStart !== windowStart) return {
-			windowStart,
-			count: 0
-		};
-		return existing;
-	}
-	async makeRequest(endpoint, options, requestId = generateId("req")) {
-		const url = `${this.config.baseUrl}${endpoint}`;
-		const controller = typeof AbortController !== "undefined" ? new AbortController() : void 0;
-		const headers = {
-			"Content-Type": "application/json",
-			"X-Api-Key": this.config.apiKey,
-			"X-App-Id": this.config.appId,
-			"X-Environment": this.config.environment,
-			"X-SDK-Version": SDK_VERSION,
-			"X-Request-Id": requestId,
-			...options.headers
-		};
-		if (this.sessionId) headers["X-Session-Id"] = this.sessionId;
-		let timeoutHandle;
-		if (controller) {
-			options = {
-				...options,
-				signal: controller.signal
-			};
-			timeoutHandle = setTimeout(() => {
-				controller.abort();
-			}, this.queueConfig.requestTimeoutMs);
-		}
-		try {
-			if (this.shouldLog("trace")) {
-				console.log(`[Layers] → ${options.method || "GET"} ${url}`);
-				if (options.method === "POST" && options.body) console.log(`[Layers] Request body:`, JSON.parse(options.body));
-			}
-			const response = await fetch(url, {
-				...options,
-				headers
-			});
-			if (this.shouldLog("trace")) console.log(`[Layers] ← ${response.status} ${response.statusText}`);
-			if (!response.ok) {
-				if (!this.isRetryableStatus(response.status)) {
-					const error$1 = Object.assign(/* @__PURE__ */ new Error(`HTTP ${response.status}: ${response.statusText}`), { status: response.status });
-					if (this.shouldLog("debug")) console.warn(`[Layers] Non-retryable error for ${url}:`, error$1);
-					throw error$1;
-				}
-				const error = Object.assign(/* @__PURE__ */ new Error(`Retryable HTTP ${response.status}`), { status: response.status });
-				if (this.shouldLog("debug")) console.warn(`[Layers] Retryable error for ${url}:`, error);
-				throw error;
-			}
-			if (response.status === 204) return;
-			const text = await response.text();
-			if (!text) return;
-			const parsed = JSON.parse(text);
-			if (this.shouldLog("trace")) console.log(`[Layers] Response:`, parsed);
-			return parsed;
-		} finally {
-			if (timeoutHandle) clearTimeout(timeoutHandle);
-		}
-	}
-	isRetryableStatus(status) {
-		if (status === 429 || status >= 500 && status < 600) return true;
-		return false;
-	}
-	generateEventId() {
-		return generateId("evt");
-	}
-	generateBatchId() {
-		return generateId("batch");
-	}
-	getRemoteConfig() {
-		return this.remoteConfig;
-	}
-	getRemoteConfigVersion() {
-		return this.remoteConfigMeta.version;
-	}
-	getConsentState() {
-		return { ...this.consentState };
-	}
-	setAppUserId(appUserId) {
-		this.config.appUserId = appUserId;
-		if (this.shouldLog("info")) console.log(`[Layers] App user ID set: ${appUserId || "(cleared)"}`);
-	}
-	/** @deprecated Use setAppUserId instead */
-	setUserId(userId) {
-		this.setAppUserId(userId);
-	}
-	getConfig() {
-		return { ...this.config };
-	}
-	getAppUserId() {
-		return this.resolveAppUserId();
-	}
-	/** @deprecated Use getAppUserId instead */
-	getUserId() {
-		return this.resolveAppUserId();
-	}
-	getSessionId() {
-		return this.sessionId;
-	}
-	async flush() {
-		await this.processQueue();
-	}
-	setDeviceInfo(deviceInfo) {
-		this.deviceInfo = {
-			...this.deviceInfo,
-			...Object.fromEntries(Object.entries(deviceInfo).filter(([, value]) => value !== void 0 && value !== null))
-		};
-	}
-	startNewSession() {
-		this.sessionId = this.generateSessionId();
-	}
-};
-function createDefaultQueueStorage(appId) {
-	if (typeof window === "undefined") return null;
-	try {
-		if (!window.localStorage) return null;
-	} catch {
-		return null;
-	}
-	return createLocalStorageQueueStorage(`layers_queue_${appId}`);
-}
-function createLocalStorageQueueStorage(storageKey) {
-	return {
-		async load() {
-			try {
-				const raw = window.localStorage.getItem(storageKey);
-				if (!raw) return null;
-				const parsed = JSON.parse(raw);
-				if (!parsed || typeof parsed !== "object") return null;
-				return parsed;
-			} catch (error) {
-				console.warn("Failed to load queue from localStorage", error);
-				return null;
-			}
-		},
-		async save(snapshot) {
-			try {
-				window.localStorage.setItem(storageKey, JSON.stringify(snapshot));
-			} catch (error) {
-				console.warn("Failed to persist queue to localStorage", error);
-			}
-		},
-		async clear() {
-			try {
-				window.localStorage.removeItem(storageKey);
-			} catch (error) {
-				console.warn("Failed to clear queue storage", error);
-			}
-		}
-	};
-}
+import { i as getAttributionProperties, n as LayersError, r as getAttribution, t as LayersClient } from "./src-CDTj2A6Q.js";
 
-//#endregion
-export { LayersClient };
-//# sourceMappingURL=index.js.map
+export { LayersClient, LayersError, getAttribution, getAttributionProperties };