@faststats/web 0.5.0 → 0.6.0

package/dist/chunks/api-urls-CaNa8upY.js

@@ -0,0 +1,45 @@
+//#region src/utils/api-urls.ts
+const ANALYTICS_BASE = "https://metrics.faststats.dev";
+const FEATURE_FLAGS_BASE = "https://flags.faststats.dev";
+function resolveBaseUrl(input, fallback) {
+	return input?.replace(/\/+$/, "") || fallback;
+}
+const URLS = {
+	events: "/v1/web",
+	identify: "/v1/identify",
+	replay: "/v1/replay",
+	vitals: "/v1/vitals",
+	flags: "/v1/check"
+};
+function sanitizeUrl(url) {
+	try {
+		const parsed = new URL(url, location.href);
+		return `${parsed.origin}${parsed.pathname}`;
+	} catch {
+		return url.split(/[?#]/, 1)[0] ?? "";
+	}
+}
+const UTM_KEYS = [
+	"utm_source",
+	"utm_medium",
+	"utm_campaign",
+	"utm_term",
+	"utm_content"
+];
+function getPageContext() {
+	const ctx = {
+		page: location.pathname,
+		url: sanitizeUrl(location.href),
+		referrer: document.referrer ? sanitizeUrl(document.referrer) : null,
+		title: document.title || ""
+	};
+	if (!location.search) return ctx;
+	const sp = new URLSearchParams(location.search);
+	for (const key of UTM_KEYS) {
+		const value = sp.get(key);
+		if (value) ctx[key] = value;
+	}
+	return ctx;
+}
+//#endregion
+export { resolveBaseUrl as a, getPageContext as i, FEATURE_FLAGS_BASE as n, sanitizeUrl as o, URLS as r, ANALYTICS_BASE as t };

package/dist/chunks/identifiers-cUymVK5H.js

@@ -0,0 +1,20 @@
+import { d as setStorageItem, i as isCookielessMode, l as getStorageItem, n as createId, u as removeStorageItem } from "./send-data-DjdbGDDc.js";
+//#region src/utils/identifiers.ts
+const ANONYMOUS_ID_KEY = "faststats_anon_id";
+function getOrCreateAnonymousId() {
+	const existingId = getStorageItem("localStorage", ANONYMOUS_ID_KEY);
+	if (existingId) return existingId;
+	const newId = createId();
+	return setStorageItem("localStorage", ANONYMOUS_ID_KEY, newId) ? newId : "";
+}
+function getAnonymousId(cookieless) {
+	if (cookieless ?? isCookielessMode()) return "";
+	return getOrCreateAnonymousId();
+}
+function resetAnonymousId(cookieless) {
+	if (cookieless) return "";
+	if (!removeStorageItem("localStorage", ANONYMOUS_ID_KEY)) return "";
+	return getOrCreateAnonymousId();
+}
+//#endregion
+export { resetAnonymousId as n, getAnonymousId as t };

package/dist/chunks/{replay-CLfrGjqj.d.ts → replay-DgodPHzA.d.ts}

@@ -43,32 +43,34 @@ declare class ReplayTracker {
   private readonly minReplayLengthMs;
   private readonly events;
   private readonly pending;
+  private readonly minLengthBlockedBatches;
   private queuedEventsSizeBytes;
   private pendingSizeBytes;
   private viewId;
   private chunkStartedAt;
   private started;
+  private disposed;
   private startGeneration;
   private startTime;
   private sequence;
   private intervalId;
   private flushTask;
   private retryTask;
+  private retryAttempt;
   private minLengthFlushTask;
   private stopRecording?;
   private sending;
-  private flushQueued;
-  private flushQueuedLowLatency;
+  private inFlightBatch;
+  private queuedFlush;
   private unsubscribeRotation?;
   private lastCookielessMode;
   constructor(options: ReplayTrackerOptions);
   private log;
   private clearFlushTimers;
   private clearQueues;
-  private storage;
-  private counterKey;
-  private readCounter;
-  private writeCounter;
+  private dropMinLengthBlockedBatches;
+  private unblockSessionBatches;
+  private finalizeSessionPending;
   private nextBatchSequence;
   setCookielessMode(cookieless: boolean): void;
   start(): void;
@@ -78,6 +80,8 @@ declare class ReplayTracker {
   private beginRecording;
   stop(): void;
   private onSessionRotated;
+  private applySessionRotation;
+  private resetSessionTiming;
   private onEvent;
   private onUnload;
   private hasReachedMinLength;
@@ -89,9 +93,11 @@ declare class ReplayTracker {
   private eventSizeBytes;
   private batchSizeBytes;
   private dropOldestPending;
+  private removePending;
   private enqueueBatch;
   private flush;
   private scheduleRetry;
+  private retryDelay;
   private sendBatch;
 }
 //#endregion

package/dist/chunks/send-data-DjdbGDDc.js

@@ -0,0 +1,196 @@
+//#region src/utils/storage.ts
+function getStorageItem(name, key) {
+	try {
+		return globalThis[name]?.getItem(key) ?? null;
+	} catch {
+		return null;
+	}
+}
+function setStorageItem(name, key, value) {
+	try {
+		const storage = globalThis[name];
+		if (!storage) return false;
+		storage.setItem(key, value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function removeStorageItem(name, key) {
+	try {
+		const storage = globalThis[name];
+		if (!storage) return false;
+		storage.removeItem(key);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/utils/session-manager.ts
+const IDLE_MS = 1800 * 1e3;
+const MAX_AGE_MS = 1440 * 60 * 1e3;
+const SESSION_KEY = "faststats_session";
+let cookielessMode = false;
+let memorySession = null;
+const rotationListeners = /* @__PURE__ */ new Set();
+function createId() {
+	if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
+	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function readSession() {
+	const raw = getStorageItem("localStorage", SESSION_KEY);
+	if (!raw) return memorySession;
+	try {
+		const session = JSON.parse(raw);
+		return session.id ? session : memorySession;
+	} catch {}
+	return memorySession;
+}
+function writeSession(session) {
+	if (!setStorageItem("localStorage", SESSION_KEY, JSON.stringify(session))) memorySession = session;
+}
+function clearSession() {
+	memorySession = null;
+	removeStorageItem("localStorage", SESSION_KEY);
+}
+function expired(session, now) {
+	return now - session.activity >= IDLE_MS || now - session.start >= MAX_AGE_MS;
+}
+function emitRotation(prev, next) {
+	for (const listener of rotationListeners) listener(prev, next);
+}
+function resolveSession(cookieless, touch) {
+	const now = Date.now();
+	if (cookieless) {
+		if (!memorySession) memorySession = {
+			id: createId(),
+			start: now,
+			activity: now
+		};
+		else if (touch) memorySession.activity = now;
+		return {
+			session: memorySession,
+			rotatedFrom: null
+		};
+	}
+	const existing = readSession();
+	if (existing && !expired(existing, now)) {
+		if (touch) {
+			existing.activity = now;
+			writeSession(existing);
+		}
+		return {
+			session: existing,
+			rotatedFrom: null
+		};
+	}
+	const session = {
+		id: createId(),
+		start: now,
+		activity: now
+	};
+	writeSession(session);
+	return {
+		session,
+		rotatedFrom: existing
+	};
+}
+function windowId(siteKey, cookieless, sessionId) {
+	if (cookieless) return sessionId;
+	const key = `faststats_window_id_${siteKey}`;
+	const existing = getStorageItem("sessionStorage", key);
+	if (existing) return existing;
+	const id = createId();
+	return setStorageItem("sessionStorage", key, id) ? id : sessionId;
+}
+function toContext(siteKey, session, cookieless, windowIdOverride) {
+	return {
+		sessionId: session.id,
+		windowId: windowIdOverride ?? windowId(siteKey, cookieless, session.id),
+		sessionStart: session.start
+	};
+}
+function setCookielessMode(mode) {
+	cookielessMode = mode;
+	memorySession = null;
+}
+function isCookielessMode() {
+	return cookielessMode;
+}
+function getSessionContext(siteKey, cookieless) {
+	const useCookieless = cookieless ?? cookielessMode;
+	const { session, rotatedFrom } = resolveSession(useCookieless, false);
+	const next = toContext(siteKey, session, useCookieless);
+	if (rotatedFrom) emitRotation(toContext(siteKey, rotatedFrom, useCookieless, next.windowId), next);
+	return next;
+}
+function touchActivity(siteKey, cookieless) {
+	const useCookieless = cookieless ?? cookielessMode;
+	const { session, rotatedFrom } = resolveSession(useCookieless, true);
+	if (!rotatedFrom) return null;
+	const wid = windowId(siteKey, useCookieless, session.id);
+	const rotation = {
+		prev: toContext(siteKey, rotatedFrom, useCookieless, wid),
+		next: toContext(siteKey, session, useCookieless, wid)
+	};
+	emitRotation(rotation.prev, rotation.next);
+	return rotation;
+}
+function resetSession(siteKey) {
+	const useCookieless = cookielessMode;
+	const previous = getSessionContext(siteKey, useCookieless);
+	clearSession();
+	if (useCookieless) {
+		const now = Date.now();
+		memorySession = {
+			id: createId(),
+			start: now,
+			activity: now
+		};
+	} else removeStorageItem("sessionStorage", `faststats_window_id_${siteKey}`);
+	const next = getSessionContext(siteKey, useCookieless);
+	if (previous.sessionId !== next.sessionId) emitRotation(previous, next);
+	return next;
+}
+function onSessionRotated(listener) {
+	rotationListeners.add(listener);
+	return () => rotationListeners.delete(listener);
+}
+//#endregion
+//#region src/utils/send-data.ts
+async function sendData(options) {
+	const { url, data, contentType = "application/json", headers = {}, debug = false, debugPrefix = "[Analytics]", useBeacon = true, keepalive = true, signal } = options;
+	if (signal?.aborted) return false;
+	if (useBeacon && typeof globalThis.navigator?.sendBeacon === "function") try {
+		const beaconBody = data instanceof Blob || typeof Blob === "undefined" ? data : new Blob([data], { type: contentType });
+		if (globalThis.navigator.sendBeacon(url, beaconBody)) {
+			if (debug) console.log(`${debugPrefix} Sent via beacon`);
+			return true;
+		}
+	} catch {}
+	try {
+		const response = await fetch(url, {
+			method: "POST",
+			body: data,
+			headers: {
+				"Content-Type": contentType,
+				...headers
+			},
+			keepalive,
+			credentials: "omit",
+			signal
+		});
+		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;
+	}
+}
+//#endregion
+export { onSessionRotated as a, touchActivity as c, setStorageItem as d, isCookielessMode as i, getStorageItem as l, createId as n, resetSession as o, getSessionContext as r, setCookielessMode as s, sendData as t, removeStorageItem as u };

package/dist/error.d.ts

@@ -29,6 +29,7 @@ declare class ErrorTracker {
   captureError(error: Error): void;
   private onError;
   private onRejection;
+  private addToQueue;
   private enqueue;
   private flush;
 }

package/dist/error.js

@@ -1,2 +1,127 @@
-import{a as e,i as t,r as n,t as r}from"./chunks/api-urls-Bh77rElT.js";import{r as i,t as a}from"./chunks/send-data-CIbuTxPh.js";import{t as o}from"./chunks/identifiers-DcGHdsnG.js";const s=/(?:^|\()(chrome|moz|ms-browser|safari-web)-extension:\/\//;function c(e,t,n,r){return t instanceof Error?{error:e,message:t.message||r,handled:n,stack:t.stack?.split(`
-`).map(e=>e.trim()).filter(Boolean)}:{error:e,message:typeof t==`string`?t:r,handled:n}}function l({error:e,message:t,handled:n}){return`${e}\0${t??``}\0${n}`}function u(e,t){let n=t instanceof Error?t.stack??``:``;return s.test(`${e}\n${n}`)}var d=class{options;endpoint;queue=new Map;timer=null;started=!1;flushing=!1;constructor(t){this.options=t,this.endpoint=`${e(t.baseUrl,r)}${n.events}`}log(...e){this.options.debug&&console.log(`[ErrorTracker]`,...e)}start(){this.started||typeof window>`u`||(this.started=!0,window.addEventListener(`error`,this.onError),window.addEventListener(`unhandledrejection`,this.onRejection),this.timer=setInterval(()=>void this.flush(),this.options.flushInterval??5e3),this.log(`Started`))}stop(){!this.started||typeof window>`u`||(this.started=!1,window.removeEventListener(`error`,this.onError),window.removeEventListener(`unhandledrejection`,this.onRejection),this.timer&&clearInterval(this.timer),this.timer=null,this.flush(),this.log(`Stopped`))}onPageHidden(e=!1){e||this.flush()}captureError(e){this.enqueue(c(`Error`,e,!0,e.message))}onError=e=>{u(e.filename??``,e.error)||this.enqueue(c(`Error`,e.error,!1,e.message||`Unknown error`))};onRejection=e=>{u(``,e.reason)||this.enqueue(c(`UnhandledRejection`,e.reason,!1,`Unhandled promise rejection`))};enqueue(e){let t=l(e),n=this.queue.get(t);if(n){n.count++;return}this.queue.set(t,{...e,count:1}),this.log(`Captured:`,e),this.queue.size>=(this.options.maxQueueSize??50)&&this.flush()}async flush(){if(this.flushing||this.queue.size===0)return;this.flushing=!0;let e=this.queue;this.queue=new Map;let n=[...e.values()];this.log(`Flushing:`,n);try{let r=globalThis.__SOURCEMAPS_BUILD__?.buildId,s=o(),c=i(this.options.siteKey);if(!await a({url:this.endpoint,data:JSON.stringify({token:this.options.siteKey,...s?{userId:s}:{},sessionId:c.sessionId,windowId:c.windowId,...typeof r==`string`&&r.trim()?{buildId:r}:{},sdkName:this.options.sdkName??`@faststats/web`,sdkVersion:this.options.sdkVersion??`0.5.0`,event:`error`,...t(),properties:{},errors:n}),debug:this.options.debug,debugPrefix:`[ErrorTracker]`}))for(let[t,n]of e){let e=this.queue.get(t);e?e.count+=n.count:this.queue.set(t,n)}}finally{this.flushing=!1}}};export{d as default};
+import { a as resolveBaseUrl, i as getPageContext, r as URLS, t as ANALYTICS_BASE } from "./chunks/api-urls-CaNa8upY.js";
+import { r as getSessionContext, t as sendData } from "./chunks/send-data-DjdbGDDc.js";
+import { t as getAnonymousId } from "./chunks/identifiers-cUymVK5H.js";
+//#region src/error.ts
+const SDK_NAME = "@faststats/web";
+const SDK_VERSION = "0.6.0";
+const EXTENSION_RE = /(?:^|\()(chrome|moz|ms-browser|safari-web)-extension:\/\//;
+function toEntry(kind, source, handled, fallback) {
+	if (source instanceof Error) return {
+		error: kind,
+		message: source.message || fallback,
+		handled,
+		stack: source.stack?.split("\n").map((line) => line.trim()).filter(Boolean)
+	};
+	return {
+		error: kind,
+		message: typeof source === "string" ? source : fallback,
+		handled
+	};
+}
+function entryKey({ error, message, handled }) {
+	return `${error}\0${message ?? ""}\0${handled}`;
+}
+function isExtensionError(filename, source) {
+	const stack = source instanceof Error ? source.stack ?? "" : "";
+	return EXTENSION_RE.test(`${filename}\n${stack}`);
+}
+var ErrorTracker = class {
+	options;
+	endpoint;
+	queue = /* @__PURE__ */ new Map();
+	timer = null;
+	started = false;
+	flushing = false;
+	constructor(options) {
+		this.options = options;
+		this.endpoint = `${resolveBaseUrl(options.baseUrl, ANALYTICS_BASE)}${URLS.events}`;
+	}
+	log(...args) {
+		if (this.options.debug) console.log("[ErrorTracker]", ...args);
+	}
+	start() {
+		if (this.started || typeof window === "undefined") return;
+		this.started = true;
+		window.addEventListener("error", this.onError);
+		window.addEventListener("unhandledrejection", this.onRejection);
+		this.timer = setInterval(() => void this.flush(), this.options.flushInterval ?? 5e3);
+		this.log("Started");
+	}
+	stop() {
+		if (!this.started || typeof window === "undefined") return;
+		this.started = false;
+		window.removeEventListener("error", this.onError);
+		window.removeEventListener("unhandledrejection", this.onRejection);
+		if (this.timer) clearInterval(this.timer);
+		this.timer = null;
+		this.flush();
+		this.log("Stopped");
+	}
+	onPageHidden(persisted = false) {
+		if (persisted) return;
+		this.flush();
+	}
+	captureError(error) {
+		this.enqueue(toEntry("Error", error, true, error.message));
+	}
+	onError = (event) => {
+		if (isExtensionError(event.filename ?? "", event.error)) return;
+		this.enqueue(toEntry("Error", event.error, false, event.message || "Unknown error"));
+	};
+	onRejection = (event) => {
+		if (isExtensionError("", event.reason)) return;
+		this.enqueue(toEntry("UnhandledRejection", event.reason, false, "Unhandled promise rejection"));
+	};
+	addToQueue(entry, count = 1) {
+		const key = entryKey(entry);
+		const existing = this.queue.get(key);
+		if (existing) {
+			existing.count += count;
+			return false;
+		}
+		this.queue.set(key, {
+			...entry,
+			count
+		});
+		return true;
+	}
+	enqueue(entry) {
+		if (this.addToQueue(entry)) this.log("Captured:", entry);
+		if (this.queue.size >= (this.options.maxQueueSize ?? 50)) this.flush();
+	}
+	async flush() {
+		if (this.flushing || this.queue.size === 0) return;
+		this.flushing = true;
+		const batch = this.queue;
+		this.queue = /* @__PURE__ */ new Map();
+		const errors = [...batch.values()];
+		this.log("Flushing:", errors);
+		try {
+			const buildId = globalThis.__SOURCEMAPS_BUILD__?.buildId;
+			const userId = getAnonymousId();
+			const ctx = getSessionContext(this.options.siteKey);
+			if (!await sendData({
+				url: this.endpoint,
+				data: JSON.stringify({
+					token: this.options.siteKey,
+					...userId ? { userId } : {},
+					sessionId: ctx.sessionId,
+					windowId: ctx.windowId,
+					...typeof buildId === "string" && buildId.trim() ? { buildId } : {},
+					sdkName: this.options.sdkName ?? SDK_NAME,
+					sdkVersion: this.options.sdkVersion ?? SDK_VERSION,
+					event: "error",
+					...getPageContext(),
+					properties: {},
+					errors
+				}),
+				debug: this.options.debug,
+				debugPrefix: "[ErrorTracker]"
+			})) for (const item of batch.values()) this.addToQueue(item, item.count);
+		} finally {
+			this.flushing = false;
+		}
+	}
+};
+//#endregion
+export { ErrorTracker as default };

package/dist/feature-flags.js

@@ -1 +1,32 @@
-import{a as e,n as t,r as n}from"./chunks/api-urls-Bh77rElT.js";async function r(r,i){if(!i.projectToken)throw Error(`feature flag check requires projectToken`);if(!i.identifier&&!i.externalId)throw Error(`feature flag check requires serverId or externalId`);let{baseUrl:a,projectToken:o,signal:s,attributes:c,...l}=i,u={key:r,...l};c&&Object.keys(c).length>0&&(u.attributes=c);let d={"Content-Type":`application/json`,Authorization:`Bearer ${o}`},f=`${e(a,t)}${n.flags}`,p=await fetch(f,{method:`POST`,headers:d,body:JSON.stringify(u),credentials:`omit`,signal:s});if(!p.ok){let e=await p.json().catch(()=>null),t=typeof e?.error==`string`&&e.error.length>0?` — ${e.error}`:``;throw Error(`feature flag check failed: HTTP ${p.status}${t}`)}return await p.json()}export{r as fetchFeatureFlagEvaluation};
+import { a as resolveBaseUrl, n as FEATURE_FLAGS_BASE, r as URLS } from "./chunks/api-urls-CaNa8upY.js";
+//#region src/feature-flags.ts
+async function fetchFeatureFlagEvaluation(flagKey, context) {
+	if (!context.projectToken) throw new Error("feature flag check requires projectToken");
+	if (!context.identifier && !context.externalId) throw new Error("feature flag check requires serverId or externalId");
+	const { baseUrl, projectToken, signal, attributes, ...bodyFields } = context;
+	const body = {
+		key: flagKey,
+		...bodyFields
+	};
+	if (attributes && Object.keys(attributes).length > 0) body.attributes = attributes;
+	const headers = {
+		"Content-Type": "application/json",
+		Authorization: `Bearer ${projectToken}`
+	};
+	const url = `${resolveBaseUrl(baseUrl, FEATURE_FLAGS_BASE)}${URLS.flags}`;
+	const res = await fetch(url, {
+		method: "POST",
+		headers,
+		body: JSON.stringify(body),
+		credentials: "omit",
+		signal
+	});
+	if (!res.ok) {
+		const err = await res.json().catch(() => null);
+		const detail = typeof err?.error === "string" && err.error.length > 0 ? ` — ${err.error}` : "";
+		throw new Error(`feature flag check failed: HTTP ${res.status}${detail}`);
+	}
+	return await res.json();
+}
+//#endregion
+export { fetchFeatureFlagEvaluation };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { FeatureFlagEvaluation } from "./feature-flags.js";
-import { n as ReplayTrackerOptions } from "./chunks/replay-CLfrGjqj.js";
+import { n as ReplayTrackerOptions } from "./chunks/replay-DgodPHzA.js";
 
 //#region src/analytics.d.ts
 type ConsentMode = "pending" | "granted" | "denied";
@@ -58,8 +58,9 @@ declare class WebAnalytics {
   private pageKey;
   private entry;
   private left;
-  private initialPageviewPending;
-  private initialPageviewTrigger;
+  private visitDuration;
+  private visitStartedAt;
+  private pendingPageviewTrigger;
   private consentMode;
   private readonly pendingBehavior;
   private readonly cleanup;
@@ -74,8 +75,10 @@ declare class WebAnalytics {
   private cookieless;
   private touch;
   private bind;
+  private stopHeartbeat;
   private loadChild;
   private loadOptionalTrackers;
+  private enterPage;
   private beginTracking;
   private readonly onLinkClick;
   private readonly onVisibilityChange;
@@ -99,6 +102,9 @@ declare class WebAnalytics {
   reportError(error: Error): void;
   private send;
   private leavePage;
+  private startVisit;
+  private pauseVisit;
+  private resumeVisit;
   private startHeartbeat;
   private navigate;
 }