@faststats/web 0.2.13 → 0.3.0

package/tests/replay.test.ts

@@ -1,412 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { gunzipSync } from "node:zlib";
-import ReplayTracker from "../src/replay";
-import { getOrCreateSessionId } from "../src/utils/identifiers";
-
-function decodeBody(data: string | Uint8Array): string {
-	if (typeof data === "string") return data;
-	return gunzipSync(data).toString("utf8");
-}
-
-class MockStorage {
-	private readonly data = new Map<string, string>();
-
-	getItem(key: string): string | null {
-		return this.data.get(key) ?? null;
-	}
-
-	setItem(key: string, value: string): void {
-		this.data.set(key, value);
-	}
-
-	removeItem(key: string): void {
-		this.data.delete(key);
-	}
-}
-
-type ReplayEvent = {
-	type: number;
-	timestamp: number;
-	data?: Record<string, unknown>;
-};
-
-type ReplayBatch = {
-	token: string;
-	sessionId?: string;
-	identifier?: string;
-	batchId: string;
-	sequence: number;
-	timestamp: number;
-	url: string;
-	events: ReplayEvent[];
-};
-
-type ReplayTrackerInternals = {
-	events: ReplayEvent[];
-	pending: ReplayBatch[];
-	pendingSizeBytes: number;
-	minLengthFlushTask: ReturnType<typeof setTimeout> | null;
-	retryTask: ReturnType<typeof setTimeout> | null;
-	startTime: number;
-	onEvent: (event: ReplayEvent, isCheckout?: boolean) => void;
-	flush: (lowLatency: boolean) => Promise<void>;
-	send: (
-		data: string | Uint8Array,
-		isCompressed: boolean,
-		lowLatency: boolean,
-	) => Promise<boolean>;
-};
-
-function setGlobal(name: keyof typeof globalThis, value: unknown): void {
-	Object.defineProperty(globalThis, name, {
-		configurable: true,
-		writable: true,
-		value,
-	});
-}
-
-const original = {
-	window: globalThis.window,
-	document: globalThis.document,
-	location: globalThis.location,
-	navigator: globalThis.navigator,
-	fetch: globalThis.fetch,
-	localStorage: globalThis.localStorage,
-	sessionStorage: globalThis.sessionStorage,
-};
-
-beforeEach(() => {
-	setGlobal("window", {
-		location: { href: "https://example.com/" },
-		addEventListener: () => {},
-		removeEventListener: () => {},
-	} as unknown as Window);
-	setGlobal("document", {
-		visibilityState: "visible",
-		addEventListener: () => {},
-		removeEventListener: () => {},
-	} as unknown as Document);
-	setGlobal("location", { href: "https://example.com/" } as Location);
-	setGlobal("localStorage", new MockStorage());
-	setGlobal("sessionStorage", new MockStorage());
-	setGlobal("navigator", { sendBeacon: () => false });
-	setGlobal(
-		"fetch",
-		(async () => new Response("", { status: 204 })) as unknown as typeof fetch,
-	);
-});
-
-afterEach(() => {
-	setGlobal("window", original.window);
-	setGlobal("document", original.document);
-	setGlobal("location", original.location);
-	setGlobal("navigator", original.navigator);
-	setGlobal("fetch", original.fetch);
-	setGlobal("localStorage", original.localStorage);
-	setGlobal("sessionStorage", original.sessionStorage);
-});
-
-function createTracker(
-	options: Partial<ConstructorParameters<typeof ReplayTracker>[0]> = {},
-): ReplayTrackerInternals {
-	return new ReplayTracker({
-		siteKey: "site_test",
-		...options,
-	}) as unknown as ReplayTrackerInternals;
-}
-
-describe("ReplayTracker", () => {
-	test("buffers replay events", () => {
-		const tracker = createTracker({
-			maxEvents: 1000,
-			minReplayLengthMs: Number.MAX_SAFE_INTEGER,
-		});
-
-		tracker.onEvent({ type: 2, timestamp: 1, data: {} }, false);
-		tracker.onEvent({ type: 3, timestamp: 2, data: {} }, false);
-
-		expect(tracker.events.length).toBe(2);
-	});
-
-	test("does not flush before minimum replay length", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: Number.MAX_SAFE_INTEGER,
-		});
-
-		let sent = 0;
-		tracker.send = async () => {
-			sent++;
-			return true;
-		};
-		tracker.startTime = Date.now();
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-
-		await tracker.flush(false);
-
-		expect(sent).toBe(0);
-		expect(tracker.events.length).toBe(1);
-		expect(tracker.pending.length).toBe(0);
-
-		if (tracker.minLengthFlushTask) clearTimeout(tracker.minLengthFlushTask);
-	});
-
-	test("flushes buffered events once minimum replay length is reached", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 20,
-		});
-
-		let sent = 0;
-		tracker.send = async () => {
-			sent++;
-			return true;
-		};
-		tracker.startTime = Date.now();
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-
-		await new Promise((resolve) => setTimeout(resolve, 40));
-
-		expect(sent).toBe(1);
-		expect(tracker.events.length).toBe(0);
-		expect(tracker.pending.length).toBe(0);
-	});
-
-	test("emits replay payload when flushed", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-		});
-
-		const captured: { payload: ReplayBatch | null; lowLatency: boolean } = {
-			payload: null,
-			lowLatency: false,
-		};
-		tracker.send = async (data, _isCompressed, nextLowLatency) => {
-			captured.payload = JSON.parse(decodeBody(data)) as ReplayBatch;
-			captured.lowLatency = nextLowLatency;
-			return true;
-		};
-		tracker.startTime = Date.now() - 1000;
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-
-		await tracker.flush(true);
-
-		expect(captured.payload).not.toBeNull();
-		expect(captured.payload?.token).toBe("site_test");
-		expect(captured.payload?.sessionId).toBeTruthy();
-		expect(captured.payload?.batchId).toBeTruthy();
-		expect(captured.payload?.events).toHaveLength(1);
-		expect(captured.lowLatency).toBe(true);
-		expect(tracker.pending.length).toBe(0);
-	});
-
-	test("emits stable batch ids while queued for retry", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-		});
-
-		const payloads: ReplayBatch[] = [];
-		tracker.send = async (data) => {
-			payloads.push(JSON.parse(decodeBody(data)) as ReplayBatch);
-			return payloads.length > 1;
-		};
-		tracker.startTime = Date.now() - 1000;
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-
-		await tracker.flush(false);
-		await tracker.flush(false);
-
-		expect(payloads).toHaveLength(2);
-		expect(payloads[1]?.batchId).toBe(payloads[0]?.batchId);
-		expect(payloads[1]?.sequence).toBe(payloads[0]?.sequence);
-
-		if (tracker.retryTask) clearTimeout(tracker.retryTask);
-	});
-
-	test("keeps the same replay session id across later batches", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-		});
-
-		const payloads: ReplayBatch[] = [];
-		tracker.send = async (data) => {
-			payloads.push(JSON.parse(decodeBody(data)) as ReplayBatch);
-			return true;
-		};
-
-		(tracker as unknown as { sessionId?: string }).sessionId =
-			getOrCreateSessionId();
-		tracker.startTime = Date.now() - 1000;
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-		await tracker.flush(false);
-
-		const storage = globalThis.sessionStorage as unknown as MockStorage;
-		storage.setItem("session_timestamp", "0");
-
-		tracker.onEvent({ type: 3, timestamp: Date.now(), data: {} }, false);
-		await tracker.flush(false);
-
-		expect(payloads).toHaveLength(2);
-		expect(payloads[0]?.sessionId).toBeTruthy();
-		expect(payloads[1]?.sessionId).toBe(payloads[0]?.sessionId);
-	});
-
-	test("sends replay as plain JSON when CompressionStream is unavailable", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-		});
-
-		const captured: { bodyType: "string" | "blob" | null } = {
-			bodyType: null,
-		};
-		tracker.send = async (data) => {
-			captured.bodyType = typeof data === "string" ? "string" : "blob";
-			return true;
-		};
-		tracker.startTime = Date.now() - 1000;
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-
-		await tracker.flush(false);
-
-		expect(captured.bodyType).toBe("string");
-	});
-
-	test("sends replay as gzip Uint8Array when CompressionStream is available", async () => {
-		setGlobal("window", {
-			...(globalThis.window as unknown as Record<string, unknown>),
-			CompressionStream: globalThis.CompressionStream,
-		});
-
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-		});
-
-		const captured: {
-			bodyType: "string" | "binary" | null;
-			compressed: boolean;
-			size: number;
-		} = { bodyType: null, compressed: false, size: 0 };
-		tracker.send = async (data, isCompressed) => {
-			captured.bodyType = typeof data === "string" ? "string" : "binary";
-			captured.compressed = isCompressed;
-			if (data instanceof Uint8Array) {
-				captured.size = data.byteLength;
-			}
-			return true;
-		};
-		tracker.startTime = Date.now() - 1000;
-		for (let i = 0; i < 10; i++) {
-			tracker.onEvent(
-				{
-					type: 2,
-					timestamp: Date.now(),
-					data: { i, payload: "x".repeat(500) },
-				},
-				false,
-			);
-		}
-
-		await tracker.flush(false);
-
-		expect(captured.bodyType).toBe("binary");
-		expect(captured.compressed).toBe(true);
-		expect(captured.size).toBeGreaterThan(0);
-		expect(captured.size).toBeLessThan(5000);
-	});
-
-	test("compresses on unload (low latency) flush", async () => {
-		setGlobal("window", {
-			...(globalThis.window as unknown as Record<string, unknown>),
-			CompressionStream: globalThis.CompressionStream,
-		});
-
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-		});
-
-		let compressedFlag = false;
-		let lowLatencyFlag = false;
-		tracker.send = async (_data, isCompressed, lowLatency) => {
-			compressedFlag = isCompressed;
-			lowLatencyFlag = lowLatency;
-			return true;
-		};
-		tracker.startTime = Date.now() - 1000;
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-
-		await tracker.flush(true);
-
-		expect(compressedFlag).toBe(true);
-		expect(lowLatencyFlag).toBe(true);
-	});
-
-	test("keeps failed batches queued for retry", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-		});
-
-		tracker.send = async () => false;
-		tracker.startTime = Date.now() - 1000;
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-
-		await tracker.flush(false);
-
-		expect(tracker.pending.length).toBe(1);
-		expect(tracker.retryTask).not.toBeNull();
-
-		if (tracker.retryTask) clearTimeout(tracker.retryTask);
-	});
-
-	test("drops replay batches that exceed the queue byte limit", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-			maxQueueSizeBytes: 600,
-		});
-
-		let sent = 0;
-		tracker.send = async () => {
-			sent++;
-			return true;
-		};
-		tracker.startTime = Date.now() - 1000;
-		tracker.onEvent(
-			{
-				type: 2,
-				timestamp: Date.now(),
-				data: { payload: "x".repeat(1000) },
-			},
-			false,
-		);
-
-		await tracker.flush(false);
-
-		expect(sent).toBe(0);
-		expect(tracker.pending.length).toBe(0);
-		expect(tracker.pendingSizeBytes).toBe(0);
-	});
-
-	test("keeps pending replay queue under the byte limit", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-			maxQueueSizeBytes: 900,
-		});
-
-		tracker.send = async () => false;
-		tracker.startTime = Date.now() - 1000;
-
-		for (let i = 0; i < 4; i++) {
-			tracker.onEvent(
-				{
-					type: 2,
-					timestamp: Date.now(),
-					data: { i, payload: "x".repeat(300) },
-				},
-				false,
-			);
-			await tracker.flush(false);
-		}
-
-		expect(tracker.pending.length).toBeGreaterThan(0);
-		expect(tracker.pendingSizeBytes).toBeLessThanOrEqual(900);
-
-		if (tracker.retryTask) clearTimeout(tracker.retryTask);
-	});
-});

package/tests/web-vitals.test.ts

@@ -1,208 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import WebVitalsTracker from "../src/web-vitals";
-
-type FetchCall = {
-	url: string;
-	body?: string;
-};
-
-type Harness = {
-	fetchCalls: FetchCall[];
-	fetchStatuses: number[];
-	restore(): void;
-};
-
-function setGlobal(name: keyof typeof globalThis, value: unknown): void {
-	Object.defineProperty(globalThis, name, {
-		configurable: true,
-		writable: true,
-		value,
-	});
-}
-
-function setupBrowser(): Harness {
-	const originalValues = {
-		window: globalThis.window,
-		document: globalThis.document,
-		location: globalThis.location,
-		fetch: globalThis.fetch,
-		sessionStorage: globalThis.sessionStorage,
-	};
-	const fetchCalls: FetchCall[] = [];
-	const fetchStatuses: number[] = [];
-	const listeners = new Map<string, Set<EventListenerOrEventListenerObject>>();
-	const addEventListener = (
-		type: string,
-		listener: EventListenerOrEventListenerObject,
-	): void => {
-		const existing = listeners.get(type) ?? new Set();
-		existing.add(listener);
-		listeners.set(type, existing);
-	};
-	const removeEventListener = (
-		type: string,
-		listener: EventListenerOrEventListenerObject,
-	): void => {
-		listeners.get(type)?.delete(listener);
-	};
-	const location = {
-		href: "https://example.com/",
-	};
-	const storage = new Map<string, string>();
-	const sessionStorage = {
-		getItem: (key: string) => storage.get(key) ?? null,
-		setItem: (key: string, value: string) => storage.set(key, value),
-		removeItem: (key: string) => storage.delete(key),
-	};
-
-	setGlobal("location", location as Location);
-	setGlobal("document", {
-		addEventListener,
-		removeEventListener,
-		visibilityState: "visible",
-	} as unknown as Document);
-	setGlobal("window", {
-		addEventListener,
-		removeEventListener,
-		location,
-		setTimeout,
-		clearTimeout,
-	} as unknown as Window & typeof globalThis);
-	setGlobal("sessionStorage", sessionStorage);
-	setGlobal("fetch", (async (
-		url: string | URL | Request,
-		init?: RequestInit,
-	): Promise<Response> => {
-		fetchCalls.push({
-			url: String(url),
-			body: typeof init?.body === "string" ? init.body : undefined,
-		});
-		return new Response("", { status: fetchStatuses.shift() ?? 204 });
-	}) as typeof fetch);
-
-	return {
-		fetchCalls,
-		fetchStatuses,
-		restore() {
-			setGlobal("window", originalValues.window);
-			setGlobal("document", originalValues.document);
-			setGlobal("location", originalValues.location);
-			setGlobal("fetch", originalValues.fetch);
-			setGlobal("sessionStorage", originalValues.sessionStorage);
-		},
-	};
-}
-
-function captureMetric(
-	tracker: WebVitalsTracker,
-	metric: Parameters<(metric: unknown) => void>[0],
-): void {
-	(
-		tracker as unknown as {
-			captureMetric(metric: unknown): void;
-		}
-	).captureMetric(metric);
-}
-
-let harness: Harness;
-
-beforeEach(() => {
-	harness = setupBrowser();
-});
-
-afterEach(() => {
-	harness.restore();
-});
-
-describe("WebVitalsTracker", () => {
-	test("flushes the current vitals bucket when the SPA route changes", async () => {
-		const tracker = new WebVitalsTracker({
-			siteKey: "site_test",
-			baseUrl: "https://analytics.example.com",
-			samplingPercentage: 100,
-		});
-
-		tracker.start();
-		captureMetric(tracker, {
-			name: "CLS",
-			value: 0.12,
-			id: "v1",
-			rating: "needs-improvement",
-			delta: 0.12,
-			navigationType: "navigate",
-		});
-
-		tracker.trackPageChange("https://example.com/about");
-		await new Promise((resolve) => setTimeout(resolve, 0));
-
-		expect(harness.fetchCalls.length).toBe(1);
-		const firstPayload = JSON.parse(harness.fetchCalls[0]?.body ?? "{}") as {
-			metadata?: { url?: string };
-			vitals?: Array<{ metric?: string }>;
-		};
-		expect(firstPayload.metadata?.url).toBe("https://example.com/");
-		expect(firstPayload.vitals?.[0]?.metric).toBe("CLS");
-
-		captureMetric(tracker, {
-			name: "INP",
-			value: 32,
-			id: "v2",
-			rating: "good",
-			delta: 32,
-			navigationType: "navigate",
-		});
-
-		tracker.stop();
-		await new Promise((resolve) => setTimeout(resolve, 0));
-
-		expect(harness.fetchCalls.length).toBe(2);
-		const secondPayload = JSON.parse(harness.fetchCalls[1]?.body ?? "{}") as {
-			metadata?: { url?: string };
-			vitals?: Array<{ metric?: string }>;
-		};
-		expect(secondPayload.metadata?.url).toBe("https://example.com/about");
-		expect(secondPayload.vitals?.[0]?.metric).toBe("INP");
-	});
-
-	test("keeps metrics buffered when a route flush fails", async () => {
-		harness.fetchStatuses.push(500, 204, 204);
-		const tracker = new WebVitalsTracker({
-			siteKey: "site_test",
-			baseUrl: "https://analytics.example.com",
-			samplingPercentage: 100,
-		});
-
-		tracker.start();
-		captureMetric(tracker, {
-			name: "CLS",
-			value: 0.12,
-			id: "v1",
-			rating: "needs-improvement",
-			delta: 0.12,
-			navigationType: "navigate",
-		});
-		tracker.trackPageChange("https://example.com/about");
-		await new Promise((resolve) => setTimeout(resolve, 0));
-
-		expect(harness.fetchCalls.length).toBe(1);
-
-		captureMetric(tracker, {
-			name: "INP",
-			value: 32,
-			id: "v2",
-			rating: "good",
-			delta: 32,
-			navigationType: "navigate",
-		});
-		tracker.trackPageChange("https://example.com/contact");
-		await new Promise((resolve) => setTimeout(resolve, 0));
-
-		expect(harness.fetchCalls.length).toBe(3);
-		const retriedPayload = JSON.parse(harness.fetchCalls[1]?.body ?? "{}") as {
-			metadata?: { url?: string };
-			vitals?: Array<{ metric?: string }>;
-		};
-		expect(retriedPayload.metadata?.url).toBe("https://example.com/");
-		expect(retriedPayload.vitals?.[0]?.metric).toBe("CLS");
-	});
-});

package/tsconfig.json

@@ -1,30 +0,0 @@
-{
-	"compilerOptions": {
-		// Environment setup & latest features
-		"lib": ["ESNext", "DOM"],
-		"target": "ESNext",
-		"module": "Preserve",
-		"moduleDetection": "force",
-		"jsx": "react-jsx",
-		"allowJs": true,
-
-		// Bundler mode
-		"moduleResolution": "bundler",
-		"allowImportingTsExtensions": true,
-		"verbatimModuleSyntax": true,
-		"noEmit": true,
-
-		// Best practices
-		"strict": true,
-		"skipLibCheck": true,
-		"noFallthroughCasesInSwitch": true,
-		"noUncheckedIndexedAccess": true,
-		"noImplicitOverride": true,
-
-		// Some stricter flags (disabled by default)
-		"noUnusedLocals": false,
-		"noUnusedParameters": false,
-		"noPropertyAccessFromIndexSignature": false
-	},
-	"include": ["src"]
-}

package/tsdown.config.ts

@@ -1,27 +0,0 @@
-import { defineConfig } from "tsdown";
-import pkg from "./package.json" with { type: "json" };
-
-export default defineConfig({
-	entry: {
-		index: "src/entries/main.ts",
-		"feature-flags": "src/entries/feature-flags.ts",
-		replay: "src/entries/replay.ts",
-		error: "src/entries/error.ts",
-		"web-vitals": "src/entries/web-vitals.ts",
-	},
-	format: ["esm"],
-	platform: "browser",
-	outDir: "dist",
-	dts: true,
-	minify: true,
-	deps: { onlyBundle: false },
-	checks: { pluginTimings: false },
-	define: {
-		__FASTSTATS_SDK_NAME__: JSON.stringify(pkg.name),
-		__FASTSTATS_SDK_VERSION__: JSON.stringify(pkg.version),
-	},
-	outputOptions: {
-		chunkFileNames: "chunks/[name]-[hash].js",
-		entryFileNames: "[name].js",
-	},
-});

package/worker/index.ts

@@ -1,22 +0,0 @@
-export default {
-	async fetch(
-		request: Request,
-		env: { ASSETS: { fetch: typeof fetch } },
-	): Promise<Response> {
-		const response = await env.ASSETS.fetch(request);
-
-		if (response.ok) {
-			const newHeaders = new Headers(response.headers);
-			newHeaders.set("Cache-Control", "public, max-age=31536000, immutable");
-			newHeaders.set("Access-Control-Allow-Origin", "*");
-
-			return new Response(response.body, {
-				status: response.status,
-				statusText: response.statusText,
-				headers: newHeaders,
-			});
-		}
-
-		return response;
-	},
-};

package/wrangler.toml

@@ -1,8 +0,0 @@
-name = "web-analytics"
-main = "worker/index.ts"
-compatibility_date = "2024-01-01"
-
-[assets]
-directory = "./dist"
-binding = "ASSETS"
-run_worker_first = true