@faststats/web 0.1.9 → 0.2.0

package/src/error.ts

@@ -10,18 +10,19 @@ export type ErrorEntry = {
 	cause?: ErrorEntry;
 };
 
-export type ErrorTracking = {
+export type ErrorTracking = ErrorEntry & {
 	hash: string;
 	count: number;
-} & ErrorEntry;
+};
+
+type ErrorKind = "error" | "unhandledrejection";
 
-type ErrorData = {
+type NormalizedError = {
+	kind: ErrorKind;
 	message: string;
+	stack?: string;
 	filename?: string;
 	lineno?: number;
-	colno?: number;
-	stack?: string;
-	type: "error" | "unhandledrejection";
 	handled: boolean;
 	cause?: ErrorEntry;
 };
@@ -37,248 +38,205 @@ export interface ErrorTrackingOptions {
 const EXTENSION_URL =
 	/(?:^|\()(chrome|moz|ms-browser|safari-web)-extension:\/\//;
 
-function parseStack(stack?: string): string[] | undefined {
-	if (!stack) return undefined;
-	return stack
-		.split("\n")
+const parseStack = (stack?: string): string[] | undefined =>
+	stack
+		?.split("\n")
 		.map((line) => line.trim())
-		.filter((line) => line.length > 0);
-}
+		.filter(Boolean);
 
 function serializeCause(cause: unknown): ErrorEntry | undefined {
 	if (cause instanceof Error) {
-		const name = cause.name?.trim() || "Error";
 		return {
-			error: name,
+			error: cause.name?.trim() || "Error",
 			message: cause.message,
 			stack: parseStack(cause.stack),
 			cause: serializeCause(cause.cause),
 		};
 	}
+
 	if (typeof cause === "string") {
 		return { error: "Error", message: cause };
 	}
-	return undefined;
 }
 
-function causeFingerprint(cause: ErrorEntry | undefined): string {
-	if (!cause) return "";
-	return `${cause.error}\0${cause.message ?? ""}\0${causeFingerprint(cause.cause)}`;
+function fingerprintCause(cause?: ErrorEntry): string {
+	return cause
+		? `${cause.error}\0${cause.message ?? ""}\0${fingerprintCause(cause.cause)}`
+		: "";
 }
 
-function hashErrorData(data: ErrorData): string {
+function hashError(data: NormalizedError): string {
 	const key = [
-		data.type,
+		data.kind,
 		data.handled ? "handled" : "unhandled",
 		data.message,
 		data.filename ?? "",
 		data.lineno ?? "",
-		causeFingerprint(data.cause),
+		fingerprintCause(data.cause),
 	].join("\0");
 
 	let a = 2166136261;
 	let b = 3598710387;
+
 	for (let i = 0; i < key.length; i++) {
 		const c = key.charCodeAt(i);
 		a = Math.imul(a ^ c, 16777619);
 		b = Math.imul(b ^ c, 2246822519);
 	}
-	return `err_${(a >>> 0).toString(16).padStart(8, "0")}${(b >>> 0).toString(16).padStart(8, "0")}`;
+
+	return `err_${(a >>> 0).toString(16).padStart(8, "0")}${(b >>> 0)
+		.toString(16)
+		.padStart(8, "0")}`;
 }
 
-class ErrorTracker {
+export default class ErrorTracker {
 	private readonly endpoint: string;
-	private readonly siteKey: string;
-	private readonly debug: boolean;
-	private readonly flushInterval: number;
-	private readonly maxQueueSize: number;
-
-	private readonly handledErrors = new WeakSet<Error>();
-	private readonly errorCounts = new Map<
-		string,
-		{ entry: ErrorEntry; count: number }
-	>();
-	private readonly handleVisibilityChange = (): void => {
-		if (document.visibilityState === "hidden") this.flush();
-	};
-	private readonly handlePageHide = (): void => {
-		this.flush();
-	};
-	private flushTimer: ReturnType<typeof setInterval> | null = null;
+	private readonly handled = new WeakSet<Error>();
+	private readonly queue = new Map<string, ErrorTracking>();
+	private timer: ReturnType<typeof setInterval> | null = null;
 	private started = false;
 
-	constructor(options: ErrorTrackingOptions) {
-		this.siteKey = options.siteKey;
+	constructor(private readonly options: ErrorTrackingOptions) {
 		this.endpoint = webEventsUrl(options.baseUrl);
-		this.debug = options.debug ?? false;
-		this.flushInterval = options.flushInterval ?? 5000;
-		this.maxQueueSize = options.maxQueueSize ?? 50;
+	}
+
+	private get debug(): boolean {
+		return this.options.debug ?? false;
+	}
+
+	private get flushInterval(): number {
+		return this.options.flushInterval ?? 5000;
+	}
+
+	private get maxQueueSize(): number {
+		return this.options.maxQueueSize ?? 50;
+	}
+
+	private log(...args: unknown[]): void {
+		if (this.debug) console.log("[ErrorTracker]", ...args);
 	}
 
 	start(): void {
 		if (this.started || typeof window === "undefined") return;
 		this.started = true;
 
-		window.addEventListener("error", this.handleErrorEvent);
-		window.addEventListener("unhandledrejection", this.handleRejection);
+		window.addEventListener("error", this.onError);
+		window.addEventListener("unhandledrejection", this.onRejection);
+		document.addEventListener("visibilitychange", this.onVisibilityChange);
+		window.addEventListener("pagehide", this.flush);
 
-		this.flushTimer = setInterval(() => this.flush(), this.flushInterval);
-		document.addEventListener("visibilitychange", this.handleVisibilityChange);
-		window.addEventListener("pagehide", this.handlePageHide);
-
-		if (this.debug) {
-			console.log("[ErrorTracker] Started listening for errors");
-		}
+		this.timer = setInterval(this.flush, this.flushInterval);
+		this.log("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);
-		document.removeEventListener(
-			"visibilitychange",
-			this.handleVisibilityChange,
-		);
-		window.removeEventListener("pagehide", this.handlePageHide);
+		window.removeEventListener("error", this.onError);
+		window.removeEventListener("unhandledrejection", this.onRejection);
+		document.removeEventListener("visibilitychange", this.onVisibilityChange);
+		window.removeEventListener("pagehide", this.flush);
 
-		if (this.flushTimer) {
-			clearInterval(this.flushTimer);
-			this.flushTimer = null;
-		}
+		if (this.timer) clearInterval(this.timer);
+		this.timer = null;
 
 		this.flush();
-
-		if (this.debug) {
-			console.log("[ErrorTracker] Stopped listening for errors");
-		}
+		this.log("Stopped listening for errors");
 	}
 
-	private skipDuplicate(err: unknown): boolean {
-		if (!(err instanceof Error)) return false;
-		if (this.handledErrors.has(err)) return true;
-		this.handledErrors.add(err);
-		return false;
+	captureError(error: Error): void {
+		this.record(
+			{
+				kind: "error",
+				message: error.message,
+				stack: error.stack,
+				handled: true,
+				cause: serializeCause(error.cause),
+			},
+			error,
+		);
 	}
 
-	private handleErrorEvent = (event: ErrorEvent): void => {
+	private onError = (event: ErrorEvent): void => {
 		const err = event.error;
-		if (this.skipDuplicate(err)) {
-			if (this.debug) {
-				console.log("[ErrorTracker] Skipping duplicate error:", err.message);
-			}
-			return;
-		}
 
-		this.queueError({
-			message:
-				event.message || (err instanceof Error ? err.message : "Unknown error"),
-			filename: event.filename || undefined,
-			lineno: event.lineno || undefined,
-			colno: event.colno || undefined,
-			stack: err instanceof Error ? err.stack : undefined,
-			type: "error",
-			handled: false,
-			cause: err instanceof Error ? serializeCause(err.cause) : undefined,
-		});
+		this.record(
+			{
+				kind: "error",
+				message: event.message || "Unknown error",
+				filename: event.filename || undefined,
+				lineno: event.lineno || undefined,
+				stack: err instanceof Error ? err.stack : undefined,
+				handled: false,
+				cause: err instanceof Error ? serializeCause(err.cause) : undefined,
+			},
+			err,
+		);
 	};
 
-	private handleRejection = (event: PromiseRejectionEvent): void => {
+	private onRejection = (event: PromiseRejectionEvent): void => {
 		const reason = event.reason;
-		if (this.skipDuplicate(reason)) {
-			if (this.debug) {
-				console.log(
-					"[ErrorTracker] Skipping duplicate rejection:",
-					reason instanceof Error ? reason.message : reason,
-				);
-			}
-			return;
-		}
 
-		const message =
-			reason instanceof Error
-				? reason.message
-				: typeof reason === "string"
-					? reason
-					: "Unhandled promise rejection";
-
-		this.queueError({
-			message,
-			stack: reason instanceof Error ? reason.stack : undefined,
-			type: "unhandledrejection",
-			handled: false,
-			cause: reason instanceof Error ? serializeCause(reason.cause) : undefined,
-		});
+		this.record(
+			{
+				kind: "unhandledrejection",
+				message: reason.message || "Unhandled promise rejection",
+				stack: reason.stack || undefined,
+				handled: false,
+				cause: serializeCause(reason.cause),
+			},
+			reason,
+		);
 	};
 
-	private queueError(data: ErrorData): void {
+	private onVisibilityChange = (): void => {
+		if (document.visibilityState === "hidden") this.flush();
+	};
+
+	private record(data: NormalizedError, original?: unknown): void {
+		if (original instanceof Error) {
+			if (this.handled.has(original)) {
+				this.log("Skipping duplicate:", original.message);
+				return;
+			}
+			this.handled.add(original);
+		}
+
 		if (EXTENSION_URL.test(`${data.filename ?? ""}\n${data.stack ?? ""}`)) {
 			return;
 		}
 
-		if (this.debug) {
-			console.log("[ErrorTracker] Captured error:", data);
-		}
+		const hash = hashError(data);
+		const existing = this.queue.get(hash);
 
-		const hash = hashErrorData(data);
-		const bucket = this.errorCounts.get(hash);
-		if (bucket) {
-			bucket.count++;
-			if (this.debug) {
-				console.log(
-					`[ErrorTracker] Incremented count for ${hash} to ${bucket.count}`,
-				);
-			}
+		if (existing) {
+			existing.count += 1;
 		} else {
-			const entry: ErrorEntry = {
+			this.queue.set(hash, {
+				hash,
+				count: 1,
 				error:
-					data.type === "unhandledrejection" ? "UnhandledRejection" : "Error",
+					data.kind === "unhandledrejection" ? "UnhandledRejection" : "Error",
 				message: data.message,
 				stack: parseStack(data.stack),
 				handled: data.handled,
 				...(data.cause ? { cause: data.cause } : {}),
-			};
-			this.errorCounts.set(hash, { entry, count: 1 });
-			if (this.debug) {
-				console.log(`[ErrorTracker] Queued new error: ${hash}`);
-			}
+			});
 		}
 
-		if (this.errorCounts.size >= this.maxQueueSize) {
-			this.flush();
-		}
-	}
+		this.log("Captured error:", data);
 
-	captureError(error: Error): void {
-		if (this.skipDuplicate(error)) {
-			if (this.debug) {
-				console.log("[ErrorTracker] Skipping duplicate:", error.message);
-			}
-			return;
+		if (this.queue.size >= this.maxQueueSize) {
+			this.flush();
 		}
-
-		this.queueError({
-			message: error.message,
-			stack: error.stack,
-			type: "error",
-			handled: true,
-			cause: serializeCause(error.cause),
-		});
 	}
 
-	private flush(): void {
-		if (this.errorCounts.size === 0) return;
+	private flush = (): void => {
+		if (this.queue.size === 0) return;
 
-		const errors: ErrorTracking[] = [];
-		for (const [hash, { entry, count }] of this.errorCounts) {
-			errors.push({ ...entry, hash, count });
-		}
-		this.errorCounts.clear();
-
-		if (this.debug) {
-			console.log("[ErrorTracker] Flushing errors:", errors);
-		}
+		const errors = [...this.queue.values()];
+		this.queue.clear();
 
 		const identifier = getAnonymousId();
 		const sourcemapsBuild = (
@@ -286,14 +244,15 @@ class ErrorTracker {
 				__SOURCEMAPS_BUILD__?: { buildId?: unknown };
 			}
 		).__SOURCEMAPS_BUILD__;
+
 		const buildId =
 			typeof sourcemapsBuild?.buildId === "string" &&
-			sourcemapsBuild.buildId.trim().length > 0
+			sourcemapsBuild.buildId.trim()
 				? sourcemapsBuild.buildId
 				: undefined;
 
-		const payloadString = JSON.stringify({
-			token: this.siteKey,
+		const payload = JSON.stringify({
+			token: this.options.siteKey,
 			...(identifier ? { userId: identifier } : {}),
 			sessionId: getOrCreateSessionId(),
 			...(buildId ? { buildId } : {}),
@@ -306,17 +265,14 @@ class ErrorTracker {
 			errors,
 		});
 
-		if (this.debug) {
-			console.log("[ErrorTracker] Payload:", payloadString);
-		}
+		this.log("Flushing errors:", errors);
+		this.log("Payload:", payload);
 
 		sendData({
 			url: this.endpoint,
-			data: payloadString,
+			data: payload,
 			debug: this.debug,
 			debugPrefix: "[ErrorTracker]",
 		});
-	}
+	};
 }
-
-export default ErrorTracker;

package/src/feature-flags.ts

@@ -0,0 +1,88 @@
+import { featureFlagsCheckUrl } from "./utils/api-urls";
+
+export type FeatureFlagEvaluation = {
+	enabled: boolean;
+	value?: string;
+	variantKey?: string;
+	variantValue?: string;
+};
+
+export type FeatureFlagCheckContext = {
+	baseUrl?: string;
+	projectToken?: string;
+	projectId?: string;
+	serverId?: string;
+	externalId?: string;
+	attributes?: Record<string, unknown>;
+	signal?: AbortSignal;
+};
+
+function encodeAttributes(attributes: Record<string, unknown>): string {
+	const json = JSON.stringify(attributes);
+	if (typeof btoa !== "function") {
+		return json;
+	}
+	const bytes = new TextEncoder().encode(json);
+	let binary = "";
+	for (let i = 0; i < bytes.length; i++) {
+		const b = bytes[i];
+		if (b !== undefined) binary += String.fromCharCode(b);
+	}
+	return btoa(binary);
+}
+
+export async function fetchFeatureFlagEvaluation(
+	flagKey: string,
+	context: FeatureFlagCheckContext,
+): Promise<FeatureFlagEvaluation> {
+	const url = featureFlagsCheckUrl(context.baseUrl, flagKey);
+	const headers = new Headers();
+
+	if (context.projectToken && context.projectId) {
+		throw new Error("provide either projectToken or projectId, not both");
+	}
+	if (context.serverId && context.externalId) {
+		throw new Error("provide either serverId or externalId, not both");
+	}
+
+	const projectHeader: [string, string] | undefined = context.projectToken
+		? ["X-Project-Token", context.projectToken]
+		: context.projectId
+			? ["X-Project-Id", context.projectId]
+			: undefined;
+	const subjectHeader: [string, string] | undefined = context.serverId
+		? ["X-Server-Id", context.serverId]
+		: context.externalId
+			? ["X-External-Id", context.externalId]
+			: undefined;
+
+	if (!projectHeader) {
+		throw new Error("feature flag check requires projectToken or projectId");
+	}
+	if (!subjectHeader) {
+		throw new Error("feature flag check requires serverId or externalId");
+	}
+
+	headers.set(projectHeader[0], projectHeader[1]);
+	headers.set(subjectHeader[0], subjectHeader[1]);
+
+	if (context.attributes && Object.keys(context.attributes).length > 0) {
+		headers.set("X-Attributes", encodeAttributes(context.attributes));
+	}
+
+	const res = await fetch(url, {
+		method: "GET",
+		headers,
+		credentials: "omit",
+		signal: context.signal,
+	});
+	if (!res.ok) {
+		throw new Error(`feature flag check failed: HTTP ${res.status}`);
+	}
+
+	const data = (await res.json()) as { evaluation?: FeatureFlagEvaluation };
+	const evaluation = data.evaluation;
+	return evaluation?.enabled === true || evaluation?.enabled === false
+		? evaluation
+		: { enabled: false };
+}

package/src/module.ts

@@ -14,3 +14,12 @@ export {
 	WebAnalytics,
 	type WebAnalyticsOptions,
 } from "./analytics";
+export {
+	type FeatureFlagCheckContext,
+	type FeatureFlagEvaluation,
+	fetchFeatureFlagEvaluation,
+} from "./feature-flags";
+export {
+	featureFlagsCheckUrl,
+	normalizeFeatureFlagsBaseUrl,
+} from "./utils/api-urls";