@faststats/web 0.6.0 → 0.8.0

package/dist/web-vitals.js

@@ -1,6 +1,25 @@
-import { a as resolveBaseUrl, o as sanitizeUrl, r as URLS, t as ANALYTICS_BASE } from "./chunks/api-urls-CaNa8upY.js";
-import { r as getSessionContext, t as sendData } from "./chunks/send-data-DjdbGDDc.js";
+import { a as sanitizeUrl, i as resolveBaseUrl, n as URLS, t as ANALYTICS_BASE } from "./chunks/api-urls-DWk43fu6.js";
+import { r as getSessionContext, t as sendData } from "./chunks/send-data-DFZnsaL2.js";
 //#region src/web-vitals.ts
+function webVitals(options = {}) {
+	return {
+		name: "web-vitals",
+		async setup(context) {
+			const tracker = new WebVitalsTracker({
+				...options,
+				siteKey: context.siteKey,
+				baseUrl: context.baseUrl,
+				debug: context.debug,
+				trackHash: context.trackHash,
+				cookieless: context.isCookieless()
+			});
+			context.on("pageHide", ({ persisted }) => tracker.onPageHidden(persisted));
+			context.on("consentChange", ({ cookieless }) => tracker.setCookielessMode(cookieless));
+			await tracker.start();
+			return ({ discard }) => tracker.stop(discard);
+		}
+	};
+}
 const METRIC_NAMES = /* @__PURE__ */ new Set([
 	"CLS",
 	"INP",
@@ -15,50 +34,51 @@ var WebVitalsTracker = class {
 	started = false;
 	flushing = false;
 	initialUrl = "";
-	currentUrl = "";
+	session = null;
+	cookieless;
 	constructor(options) {
 		this.options = options;
 		this.endpoint = `${resolveBaseUrl(options.baseUrl, ANALYTICS_BASE)}${URLS.vitals}`;
+		this.cookieless = options.cookieless ?? false;
+	}
+	setCookielessMode(cookieless) {
+		if (this.cookieless === cookieless) return;
+		this.cookieless = cookieless;
+		this.metrics.clear();
+		this.session = this.started ? getSessionContext(this.options.siteKey, cookieless) : null;
 	}
 	async start() {
 		if (this.started || typeof window === "undefined") return;
 		this.started = true;
-		this.initialUrl = sanitizeUrl(window.location.href);
-		this.currentUrl = this.initialUrl;
-		const mod = await (this.options.attribution ? import("web-vitals/attribution") : import("web-vitals"));
+		this.initialUrl = sanitizeUrl(window.location.href, this.options.trackHash ?? false);
+		this.session = getSessionContext(this.options.siteKey, this.cookieless);
+		const vitals = this.options.attribution ? await import("web-vitals/attribution") : await import("web-vitals");
 		if (!this.started) return;
 		const changes = { reportAllChanges: true };
-		mod.onCLS(this.onMetric, changes);
-		mod.onINP(this.onMetric, changes);
-		mod.onLCP(this.onMetric, changes);
-		mod.onFCP(this.onMetric);
-		mod.onTTFB(this.onMetric);
+		vitals.onCLS(this.onMetric, changes);
+		vitals.onINP(this.onMetric, changes);
+		vitals.onLCP(this.onMetric, changes);
+		vitals.onFCP(this.onMetric);
+		vitals.onTTFB(this.onMetric);
 	}
-	stop() {
+	stop(discard = false) {
 		if (!this.started) return;
 		this.started = false;
-		this.flush();
+		if (discard) this.metrics.clear();
+		else this.flush();
 	}
 	onPageHidden(persisted = false) {
 		if (persisted) return;
-		this.flush();
-	}
-	trackPageChange(url) {
-		if (!this.started) return;
-		const next = sanitizeUrl(url ?? window.location.href);
-		if (next === this.currentUrl) return;
-		this.currentUrl = next;
+		queueMicrotask(() => void this.flush());
 	}
 	onMetric = (metric) => {
 		if (!this.started) return;
 		const name = metric.name;
 		if (!METRIC_NAMES.has(name) || !Number.isFinite(metric.value) || metric.value < 0) return;
-		const url = this.getMetricUrl(name);
 		const { id, rating, delta, navigationType } = metric;
-		const attribution = "attribution" in metric && metric.attribution ? metric.attribution : void 0;
-		this.metrics.set(`${url}\n${name}`, {
+		const attribution = this.options.attribution && "attribution" in metric && metric.attribution ? metric.attribution : void 0;
+		this.metrics.set(name, {
 			metric: name,
-			url,
 			value: metric.value,
 			attributes: {
 				id,
@@ -69,47 +89,33 @@ var WebVitalsTracker = class {
 			}
 		});
 	};
-	getMetricUrl(metric) {
-		if (metric === "FCP" || metric === "LCP" || metric === "TTFB") return this.initialUrl;
-		return this.currentUrl || this.initialUrl;
-	}
 	async flush() {
 		if (!this.metrics.size || this.flushing) return;
 		this.flushing = true;
 		const batch = this.metrics;
 		this.metrics = /* @__PURE__ */ new Map();
-		const session = getSessionContext(this.options.siteKey);
-		const byUrl = /* @__PURE__ */ new Map();
-		for (const vital of batch.values()) {
-			const vitals = byUrl.get(vital.url) ?? [];
-			vitals.push(vital);
-			byUrl.set(vital.url, vitals);
-		}
-		const results = await Promise.all([...byUrl].map(async ([url, vitals]) => ({
-			ok: await sendData({
+		const session = this.session ?? getSessionContext(this.options.siteKey, this.cookieless);
+		let sent = false;
+		try {
+			sent = await sendData({
 				url: this.endpoint,
 				data: JSON.stringify({
 					token: this.options.siteKey,
 					sessionId: session.sessionId,
 					windowId: session.windowId,
-					vitals: vitals.map(({ url: _url, ...vital }) => vital),
-					metadata: { url }
+					vitals: [...batch.values()],
+					metadata: { url: this.initialUrl }
 				}),
 				debug: this.options.debug,
 				debugPrefix: "[WebVitals]"
-			}),
-			url,
-			vitals
-		})));
-		for (const result of results) {
-			if (result.ok) continue;
-			for (const vital of result.vitals) {
-				const key = `${result.url}\n${vital.metric}`;
-				if (!this.metrics.has(key)) this.metrics.set(key, vital);
+			});
+		} finally {
+			if (!sent) {
+				for (const [name, vital] of batch) if (!this.metrics.has(name)) this.metrics.set(name, vital);
 			}
+			this.flushing = false;
 		}
-		this.flushing = false;
 	}
 };
 //#endregion
-export { WebVitalsTracker as default };
+export { WebVitalsTracker as default, webVitals };

package/package.json

@@ -13,10 +13,10 @@
 			"import": "./dist/index.js",
 			"default": "./dist/index.js"
 		},
-		"./feature-flags": {
-			"types": "./dist/feature-flags.d.ts",
-			"import": "./dist/feature-flags.js",
-			"default": "./dist/feature-flags.js"
+		"./outbound-links": {
+			"types": "./dist/outbound-links.d.ts",
+			"import": "./dist/outbound-links.js",
+			"default": "./dist/outbound-links.js"
 		},
 		"./replay": {
 			"types": "./dist/replay.d.ts",
@@ -42,7 +42,7 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"version": "0.6.0",
+	"version": "0.8.0",
 	"scripts": {
 		"build": "tsdown && bun run check-size",
 		"dev": "bun run build",
@@ -51,15 +51,14 @@
 		"check-size": "node scripts/check-bundle-size.mjs"
 	},
 	"devDependencies": {
-		"@rrweb/types": "^2.0.1",
-		"@types/bun": "latest",
-		"tsdown": "^0.22.3",
+		"@rrweb/types": "^2.1.1",
+		"@types/bun": "^1.4.0",
+		"tsdown": "^0.22.14",
 		"typescript": "^6.0.3"
 	},
 	"dependencies": {
-		"@rrweb/record": "^2.1.0",
-		"@rrweb/rrweb-plugin-console-record": "^2.1.0",
-		"@rrweb/rrweb-plugin-sequential-id-record": "^2.1.0",
-		"web-vitals": "^6.0.0"
+		"@rrweb/record": "^2.1.1",
+		"@rrweb/rrweb-plugin-console-record": "^2.1.1",
+		"web-vitals": "^6.2.1"
 	}
 }

package/dist/chunks/api-urls-CaNa8upY.js

@@ -1,45 +0,0 @@
-//#region src/utils/api-urls.ts
-const ANALYTICS_BASE = "https://metrics.faststats.dev";
-const FEATURE_FLAGS_BASE = "https://flags.faststats.dev";
-function resolveBaseUrl(input, fallback) {
-	return input?.replace(/\/+$/, "") || fallback;
-}
-const URLS = {
-	events: "/v1/web",
-	identify: "/v1/identify",
-	replay: "/v1/replay",
-	vitals: "/v1/vitals",
-	flags: "/v1/check"
-};
-function sanitizeUrl(url) {
-	try {
-		const parsed = new URL(url, location.href);
-		return `${parsed.origin}${parsed.pathname}`;
-	} catch {
-		return url.split(/[?#]/, 1)[0] ?? "";
-	}
-}
-const UTM_KEYS = [
-	"utm_source",
-	"utm_medium",
-	"utm_campaign",
-	"utm_term",
-	"utm_content"
-];
-function getPageContext() {
-	const ctx = {
-		page: location.pathname,
-		url: sanitizeUrl(location.href),
-		referrer: document.referrer ? sanitizeUrl(document.referrer) : null,
-		title: document.title || ""
-	};
-	if (!location.search) return ctx;
-	const sp = new URLSearchParams(location.search);
-	for (const key of UTM_KEYS) {
-		const value = sp.get(key);
-		if (value) ctx[key] = value;
-	}
-	return ctx;
-}
-//#endregion
-export { resolveBaseUrl as a, getPageContext as i, FEATURE_FLAGS_BASE as n, sanitizeUrl as o, URLS as r, ANALYTICS_BASE as t };

package/dist/chunks/identifiers-cUymVK5H.js

@@ -1,20 +0,0 @@
-import { d as setStorageItem, i as isCookielessMode, l as getStorageItem, n as createId, u as removeStorageItem } from "./send-data-DjdbGDDc.js";
-//#region src/utils/identifiers.ts
-const ANONYMOUS_ID_KEY = "faststats_anon_id";
-function getOrCreateAnonymousId() {
-	const existingId = getStorageItem("localStorage", ANONYMOUS_ID_KEY);
-	if (existingId) return existingId;
-	const newId = createId();
-	return setStorageItem("localStorage", ANONYMOUS_ID_KEY, newId) ? newId : "";
-}
-function getAnonymousId(cookieless) {
-	if (cookieless ?? isCookielessMode()) return "";
-	return getOrCreateAnonymousId();
-}
-function resetAnonymousId(cookieless) {
-	if (cookieless) return "";
-	if (!removeStorageItem("localStorage", ANONYMOUS_ID_KEY)) return "";
-	return getOrCreateAnonymousId();
-}
-//#endregion
-export { resetAnonymousId as n, getAnonymousId as t };

package/dist/chunks/replay-DgodPHzA.d.ts

@@ -1,104 +0,0 @@
-import { record } from "@rrweb/record";
-import { LogLevel } from "@rrweb/rrweb-plugin-console-record";
-
-//#region src/replay.d.ts
-type RecordOptions = NonNullable<Parameters<typeof record>[0]>;
-interface ReplayTrackerOptions {
-  siteKey: string;
-  baseUrl?: string;
-  debug?: boolean;
-  compress?: boolean;
-  flushInterval?: number;
-  maxEvents?: number;
-  maxBatchSizeBytes?: number;
-  maxLowLatencyBatchSizeBytes?: number;
-  maxPendingBatches?: number;
-  maxQueueSizeBytes?: number;
-  minReplayLengthMs?: number;
-  sampling?: RecordOptions["sampling"];
-  slimDOMOptions?: RecordOptions["slimDOMOptions"];
-  maskAllInputs?: boolean;
-  maskInputOptions?: RecordOptions["maskInputOptions"];
-  blockClass?: string;
-  blockSelector?: string;
-  maskTextClass?: string;
-  maskTextSelector?: string;
-  checkoutEveryNms?: number;
-  checkoutEveryNth?: number;
-  recordConsole?: boolean;
-  consoleLevel?: LogLevel[];
-  consoleLengthThreshold?: number;
-  consoleStringLengthLimit?: number;
-}
-declare class ReplayTracker {
-  private readonly options;
-  private readonly endpoint;
-  private readonly compressionSupported;
-  private readonly flushInterval;
-  private readonly maxEvents;
-  private readonly maxBatchSizeBytes;
-  private readonly maxLowLatencyBatchSizeBytes;
-  private readonly maxPendingBatches;
-  private readonly maxQueueSizeBytes;
-  private readonly minReplayLengthMs;
-  private readonly events;
-  private readonly pending;
-  private readonly minLengthBlockedBatches;
-  private queuedEventsSizeBytes;
-  private pendingSizeBytes;
-  private viewId;
-  private chunkStartedAt;
-  private started;
-  private disposed;
-  private startGeneration;
-  private startTime;
-  private sequence;
-  private intervalId;
-  private flushTask;
-  private retryTask;
-  private retryAttempt;
-  private minLengthFlushTask;
-  private stopRecording?;
-  private sending;
-  private inFlightBatch;
-  private queuedFlush;
-  private unsubscribeRotation?;
-  private lastCookielessMode;
-  constructor(options: ReplayTrackerOptions);
-  private log;
-  private clearFlushTimers;
-  private clearQueues;
-  private dropMinLengthBlockedBatches;
-  private unblockSessionBatches;
-  private finalizeSessionPending;
-  private nextBatchSequence;
-  setCookielessMode(cookieless: boolean): void;
-  start(): void;
-  trackPageChange(url?: string): void;
-  onPageHidden(persisted?: boolean): void;
-  onPageShow(persisted?: boolean): void;
-  private beginRecording;
-  stop(): void;
-  private onSessionRotated;
-  private applySessionRotation;
-  private resetSessionTiming;
-  private onEvent;
-  private onUnload;
-  private hasReachedMinLength;
-  private requestFlush;
-  private scheduleMinLengthFlush;
-  private enqueueEventsIfReady;
-  private takeEventBatches;
-  private createBatch;
-  private eventSizeBytes;
-  private batchSizeBytes;
-  private dropOldestPending;
-  private removePending;
-  private enqueueBatch;
-  private flush;
-  private scheduleRetry;
-  private retryDelay;
-  private sendBatch;
-}
-//#endregion
-export { ReplayTrackerOptions as n, ReplayTracker as t };

package/dist/chunks/send-data-DjdbGDDc.js

@@ -1,196 +0,0 @@
-//#region src/utils/storage.ts
-function getStorageItem(name, key) {
-	try {
-		return globalThis[name]?.getItem(key) ?? null;
-	} catch {
-		return null;
-	}
-}
-function setStorageItem(name, key, value) {
-	try {
-		const storage = globalThis[name];
-		if (!storage) return false;
-		storage.setItem(key, value);
-		return true;
-	} catch {
-		return false;
-	}
-}
-function removeStorageItem(name, key) {
-	try {
-		const storage = globalThis[name];
-		if (!storage) return false;
-		storage.removeItem(key);
-		return true;
-	} catch {
-		return false;
-	}
-}
-//#endregion
-//#region src/utils/session-manager.ts
-const IDLE_MS = 1800 * 1e3;
-const MAX_AGE_MS = 1440 * 60 * 1e3;
-const SESSION_KEY = "faststats_session";
-let cookielessMode = false;
-let memorySession = null;
-const rotationListeners = /* @__PURE__ */ new Set();
-function createId() {
-	if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
-	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
-}
-function readSession() {
-	const raw = getStorageItem("localStorage", SESSION_KEY);
-	if (!raw) return memorySession;
-	try {
-		const session = JSON.parse(raw);
-		return session.id ? session : memorySession;
-	} catch {}
-	return memorySession;
-}
-function writeSession(session) {
-	if (!setStorageItem("localStorage", SESSION_KEY, JSON.stringify(session))) memorySession = session;
-}
-function clearSession() {
-	memorySession = null;
-	removeStorageItem("localStorage", SESSION_KEY);
-}
-function expired(session, now) {
-	return now - session.activity >= IDLE_MS || now - session.start >= MAX_AGE_MS;
-}
-function emitRotation(prev, next) {
-	for (const listener of rotationListeners) listener(prev, next);
-}
-function resolveSession(cookieless, touch) {
-	const now = Date.now();
-	if (cookieless) {
-		if (!memorySession) memorySession = {
-			id: createId(),
-			start: now,
-			activity: now
-		};
-		else if (touch) memorySession.activity = now;
-		return {
-			session: memorySession,
-			rotatedFrom: null
-		};
-	}
-	const existing = readSession();
-	if (existing && !expired(existing, now)) {
-		if (touch) {
-			existing.activity = now;
-			writeSession(existing);
-		}
-		return {
-			session: existing,
-			rotatedFrom: null
-		};
-	}
-	const session = {
-		id: createId(),
-		start: now,
-		activity: now
-	};
-	writeSession(session);
-	return {
-		session,
-		rotatedFrom: existing
-	};
-}
-function windowId(siteKey, cookieless, sessionId) {
-	if (cookieless) return sessionId;
-	const key = `faststats_window_id_${siteKey}`;
-	const existing = getStorageItem("sessionStorage", key);
-	if (existing) return existing;
-	const id = createId();
-	return setStorageItem("sessionStorage", key, id) ? id : sessionId;
-}
-function toContext(siteKey, session, cookieless, windowIdOverride) {
-	return {
-		sessionId: session.id,
-		windowId: windowIdOverride ?? windowId(siteKey, cookieless, session.id),
-		sessionStart: session.start
-	};
-}
-function setCookielessMode(mode) {
-	cookielessMode = mode;
-	memorySession = null;
-}
-function isCookielessMode() {
-	return cookielessMode;
-}
-function getSessionContext(siteKey, cookieless) {
-	const useCookieless = cookieless ?? cookielessMode;
-	const { session, rotatedFrom } = resolveSession(useCookieless, false);
-	const next = toContext(siteKey, session, useCookieless);
-	if (rotatedFrom) emitRotation(toContext(siteKey, rotatedFrom, useCookieless, next.windowId), next);
-	return next;
-}
-function touchActivity(siteKey, cookieless) {
-	const useCookieless = cookieless ?? cookielessMode;
-	const { session, rotatedFrom } = resolveSession(useCookieless, true);
-	if (!rotatedFrom) return null;
-	const wid = windowId(siteKey, useCookieless, session.id);
-	const rotation = {
-		prev: toContext(siteKey, rotatedFrom, useCookieless, wid),
-		next: toContext(siteKey, session, useCookieless, wid)
-	};
-	emitRotation(rotation.prev, rotation.next);
-	return rotation;
-}
-function resetSession(siteKey) {
-	const useCookieless = cookielessMode;
-	const previous = getSessionContext(siteKey, useCookieless);
-	clearSession();
-	if (useCookieless) {
-		const now = Date.now();
-		memorySession = {
-			id: createId(),
-			start: now,
-			activity: now
-		};
-	} else removeStorageItem("sessionStorage", `faststats_window_id_${siteKey}`);
-	const next = getSessionContext(siteKey, useCookieless);
-	if (previous.sessionId !== next.sessionId) emitRotation(previous, next);
-	return next;
-}
-function onSessionRotated(listener) {
-	rotationListeners.add(listener);
-	return () => rotationListeners.delete(listener);
-}
-//#endregion
-//#region src/utils/send-data.ts
-async function sendData(options) {
-	const { url, data, contentType = "application/json", headers = {}, debug = false, debugPrefix = "[Analytics]", useBeacon = true, keepalive = true, signal } = options;
-	if (signal?.aborted) return false;
-	if (useBeacon && typeof globalThis.navigator?.sendBeacon === "function") try {
-		const beaconBody = data instanceof Blob || typeof Blob === "undefined" ? data : new Blob([data], { type: contentType });
-		if (globalThis.navigator.sendBeacon(url, beaconBody)) {
-			if (debug) console.log(`${debugPrefix} Sent via beacon`);
-			return true;
-		}
-	} catch {}
-	try {
-		const response = await fetch(url, {
-			method: "POST",
-			body: data,
-			headers: {
-				"Content-Type": contentType,
-				...headers
-			},
-			keepalive,
-			credentials: "omit",
-			signal
-		});
-		const success = response.ok;
-		if (debug) {
-			const message = success ? `${debugPrefix} Sent via fetch` : `${debugPrefix} Failed: ${response.status}`;
-			console[success ? "log" : "warn"](message);
-		}
-		return success;
-	} catch {
-		if (debug) console.warn(`${debugPrefix} Failed to send`);
-		return false;
-	}
-}
-//#endregion
-export { onSessionRotated as a, touchActivity as c, setStorageItem as d, isCookielessMode as i, getStorageItem as l, createId as n, resetSession as o, getSessionContext as r, setCookielessMode as s, sendData as t, removeStorageItem as u };

package/dist/feature-flags.d.ts

@@ -1,18 +0,0 @@
-//#region src/feature-flags.d.ts
-type FeatureFlagEvaluation = {
-  value: string;
-  variantKey?: string;
-  variantValue?: string;
-};
-type FeatureFlagCheckContext = {
-  baseUrl?: string;
-  projectToken?: string;
-  identifier?: string;
-  externalId?: string;
-  sessionId?: string;
-  attributes?: Record<string, unknown>;
-  signal?: AbortSignal;
-};
-declare function fetchFeatureFlagEvaluation(flagKey: string, context: FeatureFlagCheckContext): Promise<FeatureFlagEvaluation>;
-//#endregion
-export { FeatureFlagCheckContext, FeatureFlagEvaluation, fetchFeatureFlagEvaluation };

package/dist/feature-flags.js

@@ -1,32 +0,0 @@
-import { a as resolveBaseUrl, n as FEATURE_FLAGS_BASE, r as URLS } from "./chunks/api-urls-CaNa8upY.js";
-//#region src/feature-flags.ts
-async function fetchFeatureFlagEvaluation(flagKey, context) {
-	if (!context.projectToken) throw new Error("feature flag check requires projectToken");
-	if (!context.identifier && !context.externalId) throw new Error("feature flag check requires serverId or externalId");
-	const { baseUrl, projectToken, signal, attributes, ...bodyFields } = context;
-	const body = {
-		key: flagKey,
-		...bodyFields
-	};
-	if (attributes && Object.keys(attributes).length > 0) body.attributes = attributes;
-	const headers = {
-		"Content-Type": "application/json",
-		Authorization: `Bearer ${projectToken}`
-	};
-	const url = `${resolveBaseUrl(baseUrl, FEATURE_FLAGS_BASE)}${URLS.flags}`;
-	const res = await fetch(url, {
-		method: "POST",
-		headers,
-		body: JSON.stringify(body),
-		credentials: "omit",
-		signal
-	});
-	if (!res.ok) {
-		const err = await res.json().catch(() => null);
-		const detail = typeof err?.error === "string" && err.error.length > 0 ? ` — ${err.error}` : "";
-		throw new Error(`feature flag check failed: HTTP ${res.status}${detail}`);
-	}
-	return await res.json();
-}
-//#endregion
-export { fetchFeatureFlagEvaluation };