@faststats/web 0.2.14 → 0.3.1

package/src/utils/send-data.ts

@@ -1,52 +0,0 @@
-import type { SendDataOptions } from "./types";
-
-export async function sendData(options: SendDataOptions): Promise<boolean> {
-	const {
-		url,
-		data,
-		contentType = "application/json",
-		headers = {},
-		debug = false,
-		debugPrefix = "[Analytics]",
-		useBeacon = true,
-		keepalive = true,
-	} = options;
-
-	if (useBeacon && typeof globalThis.navigator?.sendBeacon === "function") {
-		try {
-			const beaconBody =
-				data instanceof Blob
-					? data
-					: typeof Blob !== "undefined"
-						? new Blob([data as BlobPart], { type: contentType })
-						: data;
-			if (globalThis.navigator.sendBeacon(url, beaconBody as BodyInit)) {
-				if (debug) console.log(`${debugPrefix} Sent via beacon`);
-				return true;
-			}
-		} catch {}
-	}
-
-	try {
-		const response = await fetch(url, {
-			method: "POST",
-			body: data as BodyInit,
-			headers: {
-				"Content-Type": contentType,
-				...headers,
-			},
-			keepalive,
-		});
-		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;
-	}
-}

package/src/utils/session-manager.ts

@@ -1,416 +0,0 @@
-export type SessionContext = {
-	sessionId: string;
-	windowId: string;
-	sessionStart: number;
-};
-
-export type SessionRotation = {
-	prev: SessionContext;
-	next: SessionContext;
-};
-
-const SESSION_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
-const SESSION_MAX_AGE_MS = 24 * 60 * 60 * 1000;
-
-const LS_SESSION_ID = "faststats_session_id";
-const LS_SESSION_ACTIVITY = "faststats_session_activity";
-const LS_SESSION_START = "faststats_session_start";
-
-const LEGACY_SESSION_ID = "session_id";
-const LEGACY_SESSION_TIMESTAMP = "session_timestamp";
-const LEGACY_SESSION_START = "session_start";
-
-let cookielessMode = false;
-let defaultSiteKey = "";
-let ephemeralSession: {
-	sessionId: string;
-	sessionStart: number;
-	activity: number;
-} | null = null;
-
-type RotationListener = (prev: SessionContext, next: SessionContext) => void;
-const rotationListeners = new Set<RotationListener>();
-
-function storageGet(storage: Storage | undefined, key: string): string | null {
-	try {
-		return storage?.getItem(key) ?? null;
-	} catch {
-		return null;
-	}
-}
-
-function storageSet(
-	storage: Storage | undefined,
-	key: string,
-	value: string,
-): boolean {
-	if (!storage) return false;
-	try {
-		storage.setItem(key, value);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-function storageRemove(storage: Storage | undefined, key: string): void {
-	try {
-		storage?.removeItem(key);
-	} catch {}
-}
-
-function getLocalStorage(): Storage | undefined {
-	try {
-		return globalThis.localStorage;
-	} catch {
-		return undefined;
-	}
-}
-
-function getSessionStorage(): Storage | undefined {
-	try {
-		return globalThis.sessionStorage;
-	} catch {
-		return undefined;
-	}
-}
-
-function notifyRotation(prev: SessionContext, next: SessionContext): void {
-	for (const listener of rotationListeners) {
-		listener(prev, next);
-	}
-}
-
-export function createId(): string {
-	if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
-		return crypto.randomUUID();
-	}
-	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
-}
-
-export function setCookielessMode(mode: boolean): void {
-	cookielessMode = mode;
-	if (mode) ephemeralSession = null;
-}
-
-export function isCookielessMode(): boolean {
-	return cookielessMode;
-}
-
-export function setDefaultSiteKey(siteKey: string): void {
-	defaultSiteKey = siteKey;
-}
-
-function windowIdKey(siteKey: string): string {
-	return `faststats_window_id_${siteKey}`;
-}
-
-function parseTimestamp(value: string | null): number | null {
-	if (!value) return null;
-	const parsed = Number.parseInt(value, 10);
-	return Number.isFinite(parsed) ? parsed : null;
-}
-
-function migrateLegacySession(): void {
-	const session = getSessionStorage();
-	const local = getLocalStorage();
-	const legacyId = storageGet(session, LEGACY_SESSION_ID);
-	if (!legacyId || storageGet(local, LS_SESSION_ID)) {
-		if (legacyId) {
-			storageRemove(session, LEGACY_SESSION_ID);
-			storageRemove(session, LEGACY_SESSION_TIMESTAMP);
-			storageRemove(session, LEGACY_SESSION_START);
-		}
-		return;
-	}
-
-	const legacyActivity = parseTimestamp(
-		storageGet(session, LEGACY_SESSION_TIMESTAMP),
-	);
-	const legacyStart = parseTimestamp(storageGet(session, LEGACY_SESSION_START));
-	const now = Date.now();
-
-	const migrated = storageSet(local, LS_SESSION_ID, legacyId);
-	storageSet(local, LS_SESSION_ACTIVITY, String(legacyActivity ?? now));
-	storageSet(
-		local,
-		LS_SESSION_START,
-		String(legacyStart ?? legacyActivity ?? now),
-	);
-
-	if (migrated) {
-		storageRemove(session, LEGACY_SESSION_ID);
-		storageRemove(session, LEGACY_SESSION_TIMESTAMP);
-		storageRemove(session, LEGACY_SESSION_START);
-	}
-}
-
-function readPersistedSession(): {
-	sessionId: string;
-	activity: number;
-	sessionStart: number;
-} | null {
-	migrateLegacySession();
-
-	const local = getLocalStorage();
-	const sessionId = storageGet(local, LS_SESSION_ID);
-	const activity = parseTimestamp(storageGet(local, LS_SESSION_ACTIVITY));
-	const sessionStart = parseTimestamp(storageGet(local, LS_SESSION_START));
-
-	if (!sessionId || activity === null) return null;
-
-	return {
-		sessionId,
-		activity,
-		sessionStart: sessionStart ?? activity,
-	};
-}
-
-function writePersistedSession(
-	sessionId: string,
-	activity: number,
-	sessionStart: number,
-): void {
-	const local = getLocalStorage();
-	const wroteId = storageSet(local, LS_SESSION_ID, sessionId);
-	storageSet(local, LS_SESSION_ACTIVITY, activity.toString());
-	storageSet(local, LS_SESSION_START, sessionStart.toString());
-
-	if (!wroteId) {
-		ephemeralSession = { sessionId, activity, sessionStart };
-	}
-}
-
-function clearPersistedSession(): void {
-	const local = getLocalStorage();
-	storageRemove(local, LS_SESSION_ID);
-	storageRemove(local, LS_SESSION_ACTIVITY);
-	storageRemove(local, LS_SESSION_START);
-}
-
-function isSessionExpired(
-	activity: number,
-	sessionStart: number,
-	now: number,
-): boolean {
-	if (now - activity >= SESSION_IDLE_TIMEOUT_MS) return true;
-	return now - sessionStart >= SESSION_MAX_AGE_MS;
-}
-
-function ephemeralRecord(now: number): {
-	sessionId: string;
-	sessionStart: number;
-	activity: number;
-} {
-	if (!ephemeralSession) {
-		ephemeralSession = {
-			sessionId: createId(),
-			sessionStart: now,
-			activity: now,
-		};
-	}
-	return ephemeralSession;
-}
-
-function resolveSessionRecord(
-	cookieless: boolean,
-	touch: boolean,
-): {
-	sessionId: string;
-	sessionStart: number;
-	rotated: boolean;
-	previous: { sessionId: string; sessionStart: number } | null;
-} {
-	const now = Date.now();
-
-	if (cookieless) {
-		const record = ephemeralRecord(now);
-		if (touch) record.activity = now;
-		return {
-			sessionId: record.sessionId,
-			sessionStart: record.sessionStart,
-			rotated: false,
-			previous: null,
-		};
-	}
-
-	const existing = readPersistedSession() ?? ephemeralSession;
-	if (
-		existing &&
-		!isSessionExpired(existing.activity, existing.sessionStart, now)
-	) {
-		if (touch) {
-			writePersistedSession(existing.sessionId, now, existing.sessionStart);
-		}
-		return {
-			sessionId: existing.sessionId,
-			sessionStart: existing.sessionStart,
-			rotated: false,
-			previous: null,
-		};
-	}
-
-	const previous =
-		existing !== null
-			? {
-					sessionId: existing.sessionId,
-					sessionStart: existing.sessionStart,
-				}
-			: null;
-
-	const sessionId = createId();
-	writePersistedSession(sessionId, now, now);
-
-	return {
-		sessionId,
-		sessionStart: now,
-		rotated: previous !== null,
-		previous,
-	};
-}
-
-export function getOrCreateWindowId(
-	siteKey: string,
-	cookieless?: boolean,
-): string {
-	if (cookieless ?? cookielessMode) {
-		return resolveSessionRecord(true, false).sessionId;
-	}
-
-	const key = windowIdKey(siteKey);
-	const session = getSessionStorage();
-	if (!session) return resolveSessionRecord(false, false).sessionId;
-
-	const existing = storageGet(session, key);
-	if (existing) return existing;
-
-	const windowId = createId();
-	storageSet(session, key, windowId);
-	return windowId;
-}
-
-function clearWindowId(siteKey: string): void {
-	storageRemove(getSessionStorage(), windowIdKey(siteKey));
-}
-
-export function getSessionContext(
-	siteKey: string,
-	cookieless?: boolean,
-): SessionContext {
-	const useCookieless = cookieless ?? cookielessMode;
-	const record = resolveSessionRecord(useCookieless, false);
-	const windowId = getOrCreateWindowId(siteKey, useCookieless);
-
-	const context: SessionContext = {
-		sessionId: record.sessionId,
-		windowId,
-		sessionStart: record.sessionStart,
-	};
-
-	if (record.rotated && record.previous) {
-		const prev: SessionContext = {
-			sessionId: record.previous.sessionId,
-			windowId,
-			sessionStart: record.previous.sessionStart,
-		};
-		notifyRotation(prev, context);
-	}
-
-	return context;
-}
-
-export function getOrCreateSessionId(cookieless?: boolean): string {
-	return resolveSessionRecord(cookieless ?? cookielessMode, true).sessionId;
-}
-
-export function getSessionStart(cookieless?: boolean): number {
-	return resolveSessionRecord(cookieless ?? cookielessMode, false).sessionStart;
-}
-
-export function touchActivity(cookieless?: boolean): SessionRotation | null {
-	const useCookieless = cookieless ?? cookielessMode;
-	const record = resolveSessionRecord(useCookieless, true);
-	if (record.rotated && record.previous) {
-		const siteKey = defaultSiteKey || "_default";
-		const rotation = {
-			prev: {
-				sessionId: record.previous.sessionId,
-				windowId: getOrCreateWindowId(siteKey, useCookieless),
-				sessionStart: record.previous.sessionStart,
-			},
-			next: {
-				sessionId: record.sessionId,
-				windowId: getOrCreateWindowId(siteKey, useCookieless),
-				sessionStart: record.sessionStart,
-			},
-		};
-		notifyRotation(rotation.prev, rotation.next);
-		return rotation;
-	}
-	return null;
-}
-
-export function refreshSessionTimestamp(cookieless?: boolean): void {
-	const useCookieless = cookieless ?? cookielessMode;
-	const now = Date.now();
-
-	if (useCookieless) {
-		if (ephemeralSession) ephemeralSession.activity = now;
-		return;
-	}
-
-	const existing = readPersistedSession() ?? ephemeralSession;
-	if (!existing) return;
-
-	writePersistedSession(existing.sessionId, now, existing.sessionStart);
-}
-
-export function resetSession(siteKey?: string): SessionContext {
-	const key = siteKey ?? defaultSiteKey ?? "_default";
-	const now = Date.now();
-	let previous: SessionContext | null = null;
-
-	if (cookielessMode) {
-		if (ephemeralSession) {
-			previous = {
-				sessionId: ephemeralSession.sessionId,
-				windowId: ephemeralSession.sessionId,
-				sessionStart: ephemeralSession.sessionStart,
-			};
-		}
-		ephemeralSession = {
-			sessionId: createId(),
-			sessionStart: now,
-			activity: now,
-		};
-	} else {
-		const existing = readPersistedSession();
-		if (existing) {
-			previous = {
-				sessionId: existing.sessionId,
-				windowId: getOrCreateWindowId(key, false),
-				sessionStart: existing.sessionStart,
-			};
-		}
-		clearPersistedSession();
-		ephemeralSession = null;
-	}
-
-	clearWindowId(key);
-	const next = getSessionContext(key, cookielessMode);
-
-	if (previous && previous.sessionId !== next.sessionId) {
-		notifyRotation(previous, next);
-	}
-
-	return next;
-}
-
-export function onSessionRotated(
-	listener: (prev: SessionContext, next: SessionContext) => void,
-): () => void {
-	rotationListeners.add(listener);
-	return () => {
-		rotationListeners.delete(listener);
-	};
-}

package/src/utils/types.ts

@@ -1,15 +0,0 @@
-export interface SendDataOptions {
-	url: string;
-	data: string | Blob | Uint8Array;
-	contentType?: string;
-	headers?: Record<string, string>;
-	debug?: boolean;
-	debugPrefix?: string;
-	useBeacon?: boolean;
-	keepalive?: boolean;
-}
-
-export function normalizeSamplingPercentage(value: number | undefined): number {
-	if (typeof value !== "number" || !Number.isFinite(value)) return 100;
-	return Math.max(0, Math.min(100, value));
-}

package/src/web-vitals.ts

@@ -1,159 +0,0 @@
-import type { Metric, MetricWithAttribution } from "web-vitals";
-import { normalizeAnalyticsBaseUrl, URLS } from "./utils/api-urls";
-import { getOrCreateSessionId } from "./utils/session-manager";
-import { normalizeSamplingPercentage } from "./utils/types";
-
-export interface WebVitalsOptions {
-	siteKey: string;
-	baseUrl?: string;
-	debug?: boolean;
-	samplingPercentage?: number;
-	attribution?: boolean;
-}
-
-type MetricName = "CLS" | "INP" | "LCP" | "FCP" | "TTFB";
-type AnyMetric = Metric | MetricWithAttribution;
-
-type MetricPayload = {
-	metric: MetricName;
-	value: number;
-	attributes: Record<string, unknown>;
-};
-
-export default class WebVitalsTracker {
-	private readonly endpoint: string;
-	private readonly sampled: boolean;
-	private readonly metrics = new Map<MetricName, MetricPayload>();
-	private started = false;
-	private url = "";
-
-	constructor(private readonly options: WebVitalsOptions) {
-		this.endpoint = `${normalizeAnalyticsBaseUrl(options.baseUrl)}${URLS.vitals}`;
-		this.sampled =
-			Math.random() * 100 <
-			normalizeSamplingPercentage(options.samplingPercentage);
-	}
-
-	private get debug(): boolean {
-		return this.options.debug ?? false;
-	}
-
-	private log(...args: unknown[]): void {
-		if (this.debug) console.log("[WebVitals]", ...args);
-	}
-
-	async start(): Promise<void> {
-		if (this.started || typeof window === "undefined") return;
-
-		this.started = true;
-		this.url = window.location.href;
-
-		document.addEventListener("visibilitychange", this.onHidden, {
-			passive: true,
-		});
-		window.addEventListener("pagehide", this.onPageHide, { passive: true });
-
-		const mod = this.options.attribution
-			? await import("web-vitals/attribution")
-			: await import("web-vitals");
-
-		if (!this.started) return;
-
-		mod.onCLS(this.capture, { reportAllChanges: true });
-		mod.onINP(this.capture, { reportAllChanges: true });
-		mod.onLCP(this.capture, { reportAllChanges: true });
-		mod.onFCP(this.capture);
-		mod.onTTFB(this.capture);
-
-		this.log("Tracking started");
-	}
-
-	stop(): void {
-		if (!this.started || typeof window === "undefined") return;
-
-		this.started = false;
-		this.removeListeners();
-		void this.flush();
-	}
-
-	trackPageChange(url?: string): void {
-		if (!this.started || typeof window === "undefined") return;
-
-		const nextUrl = url ?? window.location.href;
-		if (nextUrl === this.url) return;
-
-		void this.flush();
-		this.url = nextUrl;
-	}
-
-	private onHidden = (): void => {
-		if (document.visibilityState === "hidden") {
-			void this.flush();
-		}
-	};
-
-	private onPageHide = (): void => {
-		void this.flush();
-	};
-
-	private capture = (metric: AnyMetric): void => {
-		if (!this.started || !this.sampled) return;
-
-		const name = metric.name as MetricName;
-		const attribution = (metric as MetricWithAttribution).attribution;
-
-		this.metrics.set(name, {
-			metric: name,
-			value: metric.value,
-			attributes: {
-				id: metric.id,
-				rating: metric.rating,
-				delta: metric.delta,
-				navigationType: metric.navigationType,
-				...(attribution ?? {}),
-			},
-		});
-	};
-
-	private async flush(): Promise<void> {
-		if (typeof window === "undefined" || typeof fetch !== "function") return;
-		if (!this.metrics.size) return;
-
-		const vitals = Array.from(this.metrics.values());
-		const url = this.url;
-		this.metrics.clear();
-
-		try {
-			const controller = new AbortController();
-			const timeoutId = window.setTimeout(() => controller.abort(), 3000);
-
-			const response = await fetch(this.endpoint, {
-				method: "POST",
-				body: JSON.stringify({
-					sessionId: getOrCreateSessionId(),
-					vitals,
-					metadata: { url },
-				}),
-				headers: {
-					"Content-Type": "application/json",
-					Authorization: `Bearer ${this.options.siteKey}`,
-				},
-				keepalive: true,
-				signal: controller.signal,
-			});
-
-			clearTimeout(timeoutId);
-
-			if (!response.ok) {
-				throw new Error(`HTTP ${response.status}`);
-			}
-		} catch (error) {
-			this.log("Failed to send metrics", error);
-		}
-	}
-
-	private removeListeners(): void {
-		document.removeEventListener("visibilitychange", this.onHidden);
-		window.removeEventListener("pagehide", this.onPageHide);
-	}
-}