@faststats/web 0.0.1

package/src/error.ts

@@ -0,0 +1,324 @@
+import type { SendDataOptions } from "./utils/types";
+
+export type ErrorEntry = {
+	error: string;
+	message?: string;
+	stack?: string[];
+	cause?: ErrorEntry;
+};
+
+export type ErrorTracking = {
+	hash: string;
+	count: number;
+} & ErrorEntry;
+
+export type ErrorData = {
+	message: string;
+	filename?: string;
+	lineno?: number;
+	colno?: number;
+	stack?: string;
+	type: "error" | "unhandledrejection";
+};
+
+export interface ErrorTrackingOptions {
+	siteKey: string;
+	endpoint?: string;
+	debug?: boolean;
+	flushInterval?: number;
+	maxQueueSize?: number;
+	getCommonData?: () => Record<string, unknown>;
+}
+
+class ErrorTracker {
+	private readonly endpoint: string;
+	private readonly siteKey: string;
+	private readonly debug: boolean;
+	private readonly flushInterval: number;
+	private readonly maxQueueSize: number;
+	private readonly getCommonData: () => Record<string, unknown>;
+
+	private readonly handledErrors = new WeakSet<Error>();
+	private readonly errorCounts = new Map<
+		string,
+		{ entry: ErrorEntry; hash: string; count: number }
+	>();
+	private flushTimer: ReturnType<typeof setInterval> | null = null;
+	private started = false;
+
+	constructor(options: ErrorTrackingOptions) {
+		this.siteKey = options.siteKey;
+		this.endpoint = options.endpoint ?? "https://metrics.faststats.dev/v1/web";
+		this.debug = options.debug ?? false;
+		this.flushInterval = options.flushInterval ?? 5000;
+		this.maxQueueSize = options.maxQueueSize ?? 50;
+		this.getCommonData = options.getCommonData ?? (() => ({}));
+	}
+
+	start(): void {
+		if (this.started || typeof window === "undefined") return;
+		if (window.__FA_isTrackingDisabled?.()) {
+			if (this.debug) {
+				console.log("[ErrorTracker] Tracking disabled via localStorage");
+			}
+			return;
+		}
+		this.started = true;
+
+		window.addEventListener("error", this.handleErrorEvent);
+		window.addEventListener("unhandledrejection", this.handleRejection);
+
+		this.flushTimer = setInterval(() => this.flush(), this.flushInterval);
+		document.addEventListener("visibilitychange", () => {
+			if (document.visibilityState === "hidden") this.flush();
+		});
+		window.addEventListener("pagehide", () => this.flush());
+
+		if (this.debug) {
+			console.log("[ErrorTracker] Started listening for errors");
+		}
+	}
+
+	stop(): void {
+		if (!this.started || typeof window === "undefined") return;
+		this.started = false;
+
+		window.removeEventListener("error", this.handleErrorEvent);
+		window.removeEventListener("unhandledrejection", this.handleRejection);
+
+		if (this.flushTimer) {
+			clearInterval(this.flushTimer);
+			this.flushTimer = null;
+		}
+
+		this.flush();
+
+		if (this.debug) {
+			console.log("[ErrorTracker] Stopped listening for errors");
+		}
+	}
+
+	private handleErrorEvent = (event: ErrorEvent): void => {
+		const error = event.error;
+
+		if (error instanceof Error) {
+			if (this.handledErrors.has(error)) {
+				if (this.debug) {
+					console.log(
+						"[ErrorTracker] Skipping duplicate error:",
+						error.message,
+					);
+				}
+				return;
+			}
+			this.handledErrors.add(error);
+		}
+
+		this.queueError({
+			message: event.message || (error?.message ?? "Unknown error"),
+			filename: event.filename || undefined,
+			lineno: event.lineno || undefined,
+			colno: event.colno || undefined,
+			stack: error?.stack || undefined,
+			type: "error",
+		});
+	};
+
+	private handleRejection = (event: PromiseRejectionEvent): void => {
+		const reason = event.reason;
+
+		if (reason instanceof Error) {
+			if (this.handledErrors.has(reason)) {
+				if (this.debug) {
+					console.log(
+						"[ErrorTracker] Skipping duplicate rejection:",
+						reason.message,
+					);
+				}
+				return;
+			}
+			this.handledErrors.add(reason);
+		}
+
+		this.queueError({
+			message:
+				reason instanceof Error
+					? reason.message
+					: typeof reason === "string"
+						? reason
+						: "Unhandled promise rejection",
+			stack: reason instanceof Error ? reason.stack : undefined,
+			type: "unhandledrejection",
+		});
+	};
+
+	private isExtensionError(errorData: ErrorData): boolean {
+		if (errorData.filename?.startsWith("chrome-extension://")) {
+			return true;
+		}
+		if (errorData.stack) {
+			const firstFrame = errorData.stack
+				.split("\n")
+				.find((line) => line.trim().startsWith("at "));
+			if (firstFrame?.includes("chrome-extension://")) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private parseStack(stack?: string): string[] | undefined {
+		if (!stack) return undefined;
+		return stack
+			.split("\n")
+			.map((line) => line.trim())
+			.filter((line) => line.length > 0);
+	}
+
+	private async generateErrorHash(errorData: ErrorData): Promise<string> {
+		const key = [
+			errorData.type,
+			errorData.message,
+			errorData.filename ?? "",
+			errorData.lineno ?? "",
+		].join(":");
+
+		const encoder = new TextEncoder();
+		const data = encoder.encode(key);
+
+		const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+		const hashArray = Array.from(new Uint8Array(hashBuffer));
+		const hashHex = hashArray
+			.map((b) => b.toString(16).padStart(2, "0"))
+			.join("");
+
+		return `err_${hashHex}`;
+	}
+
+	private async queueError(errorData: ErrorData): Promise<void> {
+		if (this.isExtensionError(errorData)) return;
+
+		if (this.debug) {
+			console.log("[ErrorTracker] Captured error:", errorData);
+		}
+
+		const hash = await this.generateErrorHash(errorData);
+		const existing = this.errorCounts.get(hash);
+
+		if (existing) {
+			existing.count++;
+			if (this.debug) {
+				console.log(
+					`[ErrorTracker] Incremented count for ${hash} to ${existing.count}`,
+				);
+			}
+		} else {
+			const entry: ErrorEntry = {
+				error:
+					errorData.type === "unhandledrejection"
+						? "UnhandledRejection"
+						: "Error",
+				message: errorData.message,
+				stack: this.parseStack(errorData.stack),
+			};
+			this.errorCounts.set(hash, { entry, hash, count: 1 });
+
+			if (this.debug) {
+				console.log(`[ErrorTracker] Queued new error: ${hash}`);
+			}
+		}
+
+		if (this.errorCounts.size >= this.maxQueueSize) {
+			this.flush();
+		}
+	}
+
+	captureError(error: Error): void {
+		if (this.handledErrors.has(error)) {
+			if (this.debug) {
+				console.log(
+					"[ErrorTracker] Skipping duplicate manual capture:",
+					error.message,
+				);
+			}
+			return;
+		}
+		this.handledErrors.add(error);
+
+		this.queueError({
+			message: error.message,
+			stack: error.stack,
+			type: "error",
+		});
+	}
+
+	private flush(): void {
+		if (this.errorCounts.size === 0) return;
+
+		const errors: ErrorTracking[] = [];
+		for (const { entry, hash, count } of this.errorCounts.values()) {
+			errors.push({ ...entry, hash, count });
+		}
+		this.errorCounts.clear();
+
+		if (this.debug) {
+			console.log("[ErrorTracker] Flushing errors:", errors);
+		}
+
+		const commonData = this.getCommonData();
+		const identifier = window.__FA_getAnonymousId?.();
+		const sourcemapsBuild = (
+			globalThis as {
+				__SOURCEMAPS_BUILD__?: { buildId?: unknown };
+			}
+		).__SOURCEMAPS_BUILD__;
+		const buildId =
+			typeof sourcemapsBuild?.buildId === "string" &&
+			sourcemapsBuild.buildId.trim().length > 0
+				? sourcemapsBuild.buildId
+				: undefined;
+
+		const payload: Record<string, unknown> = {
+			token: this.siteKey,
+			...(identifier ? { userId: identifier } : {}),
+			sessionId: window.__FA_getSessionId?.(),
+			...(buildId ? { buildId } : {}),
+			data: {
+				url: commonData.url as string,
+				page: commonData.page as string,
+				referrer: commonData.referrer as string,
+				title: typeof document !== "undefined" ? document.title : "",
+			},
+			errors,
+		};
+
+		const payloadString = JSON.stringify(payload);
+
+		if (this.debug) {
+			console.log("[ErrorTracker] Payload:", payloadString);
+		}
+
+		window.__FA_sendData?.({
+			url: this.endpoint,
+			data: payloadString,
+			debug: this.debug,
+			debugPrefix: "[ErrorTracker]",
+		});
+	}
+}
+
+export default ErrorTracker;
+
+declare global {
+	interface Window {
+		__FA_ErrorTracker?: typeof ErrorTracker;
+		__FA_getAnonymousId?: () => string;
+		__FA_getSessionId?: () => string;
+		__FA_sendData?: (options: SendDataOptions) => Promise<boolean>;
+		__FA_isTrackingDisabled?: () => boolean;
+	}
+}
+
+if (typeof window !== "undefined") {
+	window.__FA_ErrorTracker = ErrorTracker;
+}

package/src/index.ts

@@ -0,0 +1,95 @@
+import {
+	type ConsentMode,
+	isTrackingDisabled,
+	sendData,
+	WebAnalytics,
+	type WebAnalyticsOptions,
+} from "./analytics";
+
+export { isTrackingDisabled, sendData, WebAnalytics };
+export type { ConsentMode, WebAnalyticsOptions };
+
+function parseBooleanAttribute(
+	value: string | null | undefined,
+): boolean | undefined {
+	if (value == null) return undefined;
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "true" || normalized === "1") return true;
+	if (normalized === "false" || normalized === "0") return false;
+	return undefined;
+}
+
+function parseSamplingAttribute(
+	value: string | null | undefined,
+): number | undefined {
+	if (value == null || value.trim() === "") return undefined;
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed)) return undefined;
+	return Math.max(0, Math.min(100, parsed));
+}
+
+function parseConsentModeAttribute(
+	value: string | null | undefined,
+): ConsentMode | undefined {
+	if (value == null) return undefined;
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "pending") return "pending";
+	if (normalized === "granted") return "granted";
+	if (normalized === "denied") return "denied";
+	return undefined;
+}
+
+if (typeof window !== "undefined") {
+	window.WebAnalytics = WebAnalytics;
+	window.__FA_isTrackingDisabled = isTrackingDisabled;
+
+	(() => {
+		const s = document.currentScript as HTMLScriptElement | null;
+		if (!s) return;
+		const el = s;
+		const d = (k: string) => el.getAttribute(`data-${k}`);
+		const siteKey = d("sitekey");
+		if (!siteKey) return;
+		const opts: WebAnalyticsOptions = { siteKey };
+		const endpoint = d("endpoint");
+		if (endpoint) opts.endpoint = endpoint;
+		const dbg = d("debug");
+		if (dbg) opts.debug = dbg === "true";
+		const err = parseBooleanAttribute(d("trackErrors"));
+		if (err !== undefined) {
+			opts.trackErrors = err;
+			opts.errorTracking = { enabled: err };
+		}
+		const wv = parseBooleanAttribute(d("webVitals"));
+		const wvs = parseSamplingAttribute(d("web-vitals-sampling"));
+		if (wv !== undefined || wvs !== undefined) {
+			if (wv !== undefined) opts.trackWebVitals = wv;
+			opts.webVitals = {
+				enabled: wv,
+				sampling: wvs !== undefined ? { percentage: wvs } : undefined,
+			};
+		}
+		const rp = parseBooleanAttribute(d("replay"));
+		const rps = parseSamplingAttribute(d("replay-sampling"));
+		if (rp !== undefined || rps !== undefined) {
+			if (rp !== undefined) opts.trackReplay = rp;
+			opts.sessionReplays = {
+				enabled: rp,
+				sampling: rps !== undefined ? { percentage: rps } : undefined,
+			};
+		}
+		const cookieless = parseBooleanAttribute(d("cookieless"));
+		if (cookieless !== undefined) opts.cookieless = cookieless;
+		const consentMode = parseConsentModeAttribute(d("consent-mode"));
+		const cookielessWhilePending = parseBooleanAttribute(
+			d("cookieless-while-pending"),
+		);
+		if (consentMode !== undefined || cookielessWhilePending !== undefined) {
+			opts.consent = {
+				mode: consentMode,
+				cookielessWhilePending,
+			};
+		}
+		new WebAnalytics(opts);
+	})();
+}

package/src/module.ts

@@ -0,0 +1,6 @@
+export {
+	type ConsentMode,
+	type IdentifyOptions,
+	WebAnalytics,
+	type WebAnalyticsOptions,
+} from "./analytics";