@faststats/web 0.2.14 → 0.3.1

package/tests/analytics.test.ts

@@ -1,453 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import {
-	getInstance,
-	resolveReplayTrackerOptions,
-	sendData,
-	setConsentMode,
-	WebAnalytics,
-} from "../src/analytics";
-
-class MockStorage {
-	private readonly store = new Map<string, string>();
-
-	getItem(key: string): string | null {
-		return this.store.get(key) ?? null;
-	}
-
-	setItem(key: string, value: string): void {
-		this.store.set(key, value);
-	}
-
-	removeItem(key: string): void {
-		this.store.delete(key);
-	}
-}
-
-class MockNode {
-	parentNode: MockNode | null = null;
-}
-
-class MockAnchorElement extends MockNode {
-	constructor(
-		public href: string,
-		public host: string,
-	) {
-		super();
-	}
-}
-
-type Listener = EventListenerOrEventListenerObject;
-
-class MockEventTarget {
-	readonly listeners = new Map<string, Set<Listener>>();
-
-	addEventListener(type: string, listener: Listener): void {
-		const existing = this.listeners.get(type) ?? new Set<Listener>();
-		existing.add(listener);
-		this.listeners.set(type, existing);
-	}
-
-	removeEventListener(type: string, listener: Listener): void {
-		this.listeners.get(type)?.delete(listener);
-	}
-
-	listenerCount(type: string): number {
-		return this.listeners.get(type)?.size ?? 0;
-	}
-}
-
-type FetchCall = {
-	url: string;
-	body?: string;
-	headers?: Record<string, string>;
-};
-
-type BrowserHarness = {
-	windowTarget: MockEventTarget;
-	documentTarget: MockEventTarget;
-	fetchCalls: FetchCall[];
-	restore(): void;
-	location: {
-		href: string;
-		pathname: string;
-		hash: string;
-		search: string;
-	};
-	history: History;
-	navigator: {
-		sendBeacon: (url: string, data?: BodyInit | null) => boolean;
-	};
-};
-
-function wait(ms: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function setGlobal(name: keyof typeof globalThis, value: unknown): void {
-	Object.defineProperty(globalThis, name, {
-		configurable: true,
-		writable: true,
-		value,
-	});
-}
-
-function setupBrowser(): BrowserHarness {
-	const originalValues = {
-		window: globalThis.window,
-		document: globalThis.document,
-		location: globalThis.location,
-		history: globalThis.history,
-		localStorage: globalThis.localStorage,
-		sessionStorage: globalThis.sessionStorage,
-		navigator: globalThis.navigator,
-		fetch: globalThis.fetch,
-		Node: globalThis.Node,
-		HTMLAnchorElement: globalThis.HTMLAnchorElement,
-	};
-
-	const fetchCalls: FetchCall[] = [];
-	const windowTarget = new MockEventTarget();
-	const documentTarget = new MockEventTarget();
-	const localStorage = new MockStorage();
-	const sessionStorage = new MockStorage();
-	const locationState = {
-		href: "https://example.com/",
-		pathname: "/",
-		hash: "",
-		search: "",
-	};
-
-	const updateHref = (): void => {
-		locationState.href = `https://example.com${locationState.pathname}${locationState.search}${locationState.hash}`;
-	};
-
-	const history = {
-		pushState(_data: unknown, _unused: string, url?: string | URL | null) {
-			if (typeof url === "string") {
-				const parsed = new URL(url, locationState.href);
-				locationState.pathname = parsed.pathname;
-				locationState.search = parsed.search;
-				locationState.hash = parsed.hash;
-				updateHref();
-			}
-		},
-		replaceState(_data: unknown, _unused: string, url?: string | URL | null) {
-			if (typeof url === "string") {
-				const parsed = new URL(url, locationState.href);
-				locationState.pathname = parsed.pathname;
-				locationState.search = parsed.search;
-				locationState.hash = parsed.hash;
-				updateHref();
-			}
-		},
-	} as unknown as History;
-
-	const document = {
-		addEventListener: documentTarget.addEventListener.bind(documentTarget),
-		removeEventListener:
-			documentTarget.removeEventListener.bind(documentTarget),
-		referrer: "",
-		title: "FastStats",
-		visibilityState: "visible",
-		documentElement: {
-			scrollHeight: 2000,
-			scrollTop: 0,
-		},
-		body: {
-			scrollHeight: 2000,
-		},
-	} as unknown as Document;
-
-	const windowObject = {
-		addEventListener: windowTarget.addEventListener.bind(windowTarget),
-		removeEventListener: windowTarget.removeEventListener.bind(windowTarget),
-		innerHeight: 1000,
-		scrollY: 0,
-		setTimeout,
-		clearTimeout,
-		setInterval,
-		clearInterval,
-		history,
-		location: locationState,
-	} as unknown as Window & typeof globalThis;
-
-	const navigator = {
-		sendBeacon: () => false,
-	};
-
-	setGlobal("window", windowObject);
-	setGlobal("document", document);
-	setGlobal("location", locationState as Location);
-	setGlobal("history", history);
-	setGlobal("localStorage", localStorage);
-	setGlobal("sessionStorage", sessionStorage);
-	setGlobal("navigator", navigator);
-	setGlobal("fetch", (async (
-		url: string | URL | Request,
-		init?: RequestInit,
-	): Promise<Response> => {
-		let body: string | undefined;
-		if (typeof init?.body === "string") {
-			body = init.body;
-		} else if (init?.body instanceof Blob) {
-			body = await init.body.text();
-		}
-		fetchCalls.push({
-			url: String(url),
-			body,
-			headers: init?.headers as Record<string, string> | undefined,
-		});
-		return new Response("", { status: 204 });
-	}) as typeof fetch);
-	setGlobal("Node", MockNode as unknown as typeof Node);
-	setGlobal(
-		"HTMLAnchorElement",
-		MockAnchorElement as unknown as typeof HTMLAnchorElement,
-	);
-
-	return {
-		windowTarget,
-		documentTarget,
-		fetchCalls,
-		location: locationState,
-		history,
-		navigator,
-		restore() {
-			setGlobal("window", originalValues.window);
-			setGlobal("document", originalValues.document);
-			setGlobal("location", originalValues.location);
-			setGlobal("history", originalValues.history);
-			setGlobal("localStorage", originalValues.localStorage);
-			setGlobal("sessionStorage", originalValues.sessionStorage);
-			setGlobal("navigator", originalValues.navigator);
-			setGlobal("fetch", originalValues.fetch);
-			setGlobal("Node", originalValues.Node);
-			setGlobal("HTMLAnchorElement", originalValues.HTMLAnchorElement);
-		},
-	};
-}
-
-let harness: BrowserHarness;
-
-beforeEach(() => {
-	harness = setupBrowser();
-});
-
-afterEach(() => {
-	getInstance()?.destroy();
-	harness.restore();
-});
-
-describe("WebAnalytics lifecycle", () => {
-	test("start installs listeners and destroy removes them", async () => {
-		const analytics = new WebAnalytics({
-			siteKey: "site_test",
-			autoTrack: false,
-		});
-		await analytics.start();
-
-		expect(getInstance()).toBe(analytics);
-		expect(harness.windowTarget.listenerCount("pagehide")).toBe(1);
-		expect(harness.windowTarget.listenerCount("popstate")).toBe(1);
-		expect(harness.documentTarget.listenerCount("visibilitychange")).toBe(1);
-		expect(harness.documentTarget.listenerCount("click")).toBe(1);
-
-		analytics.destroy();
-
-		expect(getInstance()).toBeNull();
-		expect(harness.windowTarget.listenerCount("pagehide")).toBe(0);
-		expect(harness.windowTarget.listenerCount("popstate")).toBe(0);
-		expect(harness.documentTarget.listenerCount("visibilitychange")).toBe(0);
-		expect(harness.documentTarget.listenerCount("click")).toBe(0);
-	});
-
-	test("sendData uses beacon before fetch", async () => {
-		harness.navigator.sendBeacon = () => true;
-		const sent = await sendData({
-			url: "https://example.com/v1/web",
-			data: '{"ok":true}',
-		});
-		expect(sent).toBe(true);
-		expect(harness.fetchCalls.length).toBe(0);
-	});
-
-	test("sendData returns false when fetch is unavailable", async () => {
-		harness.navigator.sendBeacon = () => false;
-		setGlobal("fetch", undefined as unknown as typeof fetch);
-		const sent = await sendData({
-			url: "https://example.com/v1/web",
-			data: '{"ok":true}',
-		});
-		expect(sent).toBe(false);
-	});
-
-	test("sendData can skip beacon and use fetch", async () => {
-		harness.navigator.sendBeacon = () => true;
-		const sent = await sendData({
-			url: "https://example.com/v1/web",
-			data: '{"ok":true}',
-			useBeacon: false,
-		});
-		expect(sent).toBe(true);
-		expect(harness.fetchCalls.length).toBe(1);
-	});
-
-	test("module consent updates apply before instance starts", () => {
-		setConsentMode("denied");
-		const analytics = new WebAnalytics({
-			siteKey: "site_test",
-			autoTrack: false,
-			consent: { mode: "granted" },
-		});
-		expect(analytics.getConsentMode()).toBe("denied");
-	});
-
-	test("consent changes unblock identify payloads", async () => {
-		const analytics = new WebAnalytics({
-			siteKey: "site_test",
-			autoTrack: false,
-			consent: {
-				mode: "pending",
-				cookielessWhilePending: true,
-			},
-		});
-
-		await analytics.start();
-		analytics.identify("user_1", "user@example.com");
-		await wait(0);
-		expect(
-			harness.fetchCalls.some((call) => call.url.endsWith("/v1/identify")),
-		).toBe(false);
-
-		analytics.setConsentMode("granted");
-		const identified = await analytics.identify("user_1", "user@example.com", {
-			name: "User One",
-		});
-
-		const identifyCall = harness.fetchCalls.find((call) =>
-			call.url.endsWith("/v1/identify"),
-		);
-		expect(identified).toBe(true);
-		expect(identifyCall).toBeTruthy();
-		expect(identifyCall?.body).toContain('"externalId":"user_1"');
-		expect(identifyCall?.body).toContain('"email":"user@example.com"');
-	});
-
-	test("feature flag checks send identifier with external id", async () => {
-		const analytics = new WebAnalytics({
-			siteKey: "site_test",
-			autoTrack: false,
-		});
-		setGlobal("fetch", (async (
-			url: string | URL | Request,
-			init?: RequestInit,
-		): Promise<Response> => {
-			harness.fetchCalls.push({
-				url: String(url),
-				body: typeof init?.body === "string" ? init.body : undefined,
-				headers: init?.headers as Record<string, string> | undefined,
-			});
-			return Response.json({ value: "true" });
-		}) as typeof fetch);
-
-		await analytics.start();
-		await analytics.checkFeatureFlag("beta", undefined, {
-			externalId: "user_1",
-		});
-
-		const checkCall = harness.fetchCalls.find((call) =>
-			call.url.endsWith("/v1/check"),
-		);
-		expect(checkCall).toBeTruthy();
-		expect(checkCall?.body).toContain('"key":"beta"');
-		expect(checkCall?.body).toContain('"externalId":"user_1"');
-		expect(checkCall?.body).toContain('"identifier":');
-		expect(checkCall?.body).toContain('"sessionId":');
-	});
-
-	test("navigation sends page leave and navigation pageview", async () => {
-		const analytics = new WebAnalytics({
-			siteKey: "site_test",
-			autoTrack: false,
-		});
-
-		await analytics.start();
-		harness.fetchCalls.length = 0;
-
-		harness.history.pushState({}, "", "/about");
-		await wait(350);
-		await wait(0);
-
-		const payloads = harness.fetchCalls.map((call) => call.body ?? "");
-		expect(payloads.some((body) => body.includes('"event":"page_leave"'))).toBe(
-			true,
-		);
-		expect(
-			payloads.some(
-				(body) =>
-					body.includes('"event":"pageview"') &&
-					body.includes('"trigger":"navigation"') &&
-					body.includes('"page":"/about"'),
-			),
-		).toBe(true);
-	});
-
-	test("visibility hide refreshes stale session before page leave", async () => {
-		const analytics = new WebAnalytics({
-			siteKey: "site_test",
-			autoTrack: false,
-		});
-
-		await analytics.start();
-		const storage = globalThis.localStorage as unknown as MockStorage;
-		const sessionId = storage.getItem("faststats_session_id");
-		expect(sessionId).toBeTruthy();
-		storage.setItem(
-			"faststats_session_activity",
-			(Date.now() - 31 * 60 * 1000).toString(),
-		);
-		harness.fetchCalls.length = 0;
-
-		Object.defineProperty(globalThis.document, "visibilityState", {
-			configurable: true,
-			value: "hidden",
-		});
-		for (const listener of harness.documentTarget.listeners.get(
-			"visibilitychange",
-		) ?? []) {
-			if (typeof listener === "function") {
-				listener(new Event("visibilitychange"));
-			} else {
-				listener.handleEvent(new Event("visibilitychange"));
-			}
-		}
-		await wait(0);
-
-		expect(storage.getItem("faststats_session_id")).toBe(sessionId);
-		const pageLeaveCall = harness.fetchCalls.find((call) =>
-			call.body?.includes('"event":"page_leave"'),
-		);
-		expect(pageLeaveCall?.body).toContain(`"sessionId":"${sessionId}"`);
-	});
-
-	test("resolveReplayTrackerOptions honors sessionReplays config", () => {
-		const options = resolveReplayTrackerOptions(
-			{
-				siteKey: "site_test",
-				sessionReplays: {
-					enabled: true,
-					sampling: { percentage: 37 },
-				},
-			},
-			"https://metrics.example.com",
-			true,
-		);
-
-		expect(options).toMatchObject({
-			siteKey: "site_test",
-			baseUrl: "https://metrics.example.com",
-			debug: true,
-			samplingPercentage: 37,
-		});
-	});
-});

package/tests/identifiers.test.ts

@@ -1,78 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import {
-	getAnonymousId,
-	getOrCreateAnonymousId,
-	resetAnonymousId,
-} from "../src/utils/identifiers";
-import { setCookielessMode } from "../src/utils/session-manager";
-
-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);
-	}
-}
-
-function setGlobal(name: keyof typeof globalThis, value: unknown): void {
-	Object.defineProperty(globalThis, name, {
-		configurable: true,
-		writable: true,
-		value,
-	});
-}
-
-const original = {
-	localStorage: globalThis.localStorage,
-};
-
-beforeEach(() => {
-	setGlobal("localStorage", new MockStorage());
-	setCookielessMode(false);
-});
-
-afterEach(() => {
-	setGlobal("localStorage", original.localStorage);
-	setCookielessMode(false);
-});
-
-describe("identifiers", () => {
-	test("anonymous id is generated and persisted", () => {
-		const id = getOrCreateAnonymousId();
-		const second = getOrCreateAnonymousId();
-		expect(id.length).toBeGreaterThan(0);
-		expect(second).toBe(id);
-	});
-
-	test("resetAnonymousId creates a new anonymous id", () => {
-		const first = getOrCreateAnonymousId();
-		const second = resetAnonymousId();
-		expect(second.length).toBeGreaterThan(0);
-		expect(second).not.toBe(first);
-	});
-
-	test("cookieless mode skips anonymous id persistence", () => {
-		setCookielessMode(true);
-		expect(getAnonymousId()).toBe("");
-	});
-
-	test("storage access failures disable persisted anonymous id", () => {
-		Object.defineProperty(globalThis, "localStorage", {
-			configurable: true,
-			get() {
-				throw new Error("storage blocked");
-			},
-		});
-
-		expect(getOrCreateAnonymousId()).toBe("");
-		expect(resetAnonymousId()).toBe("");
-	});
-});