@faststats/web 0.5.0 → 0.7.0

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

@@ -0,0 +1,46 @@
+//#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, includeHash = false) {
+	try {
+		const parsed = new URL(url, location.href);
+		return `${parsed.origin}${parsed.pathname}${includeHash ? parsed.hash : ""}`;
+	} catch {
+		return url.split(includeHash ? "?" : /[?#]/, 1)[0] ?? "";
+	}
+}
+const UTM_KEYS = [
+	"utm_source",
+	"utm_medium",
+	"utm_campaign",
+	"utm_term",
+	"utm_content"
+];
+function getPageContext(includeHash = false) {
+	const hash = includeHash ? location.hash : "";
+	const ctx = {
+		page: `${location.pathname}${hash}`,
+		url: sanitizeUrl(location.href, includeHash),
+		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-BvRNbiwA.js

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

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

@@ -1,12 +1,27 @@
 import { record } from "@rrweb/record";
 import { LogLevel } from "@rrweb/rrweb-plugin-console-record";
 
+//#region ../../node_modules/.bun/@rrweb+types@2.1.0/node_modules/@rrweb/types/dist/index.d.ts
+declare global {
+  interface Window {
+    FontFace: typeof FontFace;
+  }
+}
+//#endregion
+//#region src/replay-mutation-throttler.d.ts
+type ReplayMutationThrottleOptions = {
+  enabled?: boolean;
+  bucketSize?: number;
+  refillRate?: number;
+};
+//#endregion
 //#region src/replay.d.ts
 type RecordOptions = NonNullable<Parameters<typeof record>[0]>;
 interface ReplayTrackerOptions {
   siteKey: string;
   baseUrl?: string;
   debug?: boolean;
+  trackHash?: boolean;
   compress?: boolean;
   flushInterval?: number;
   maxEvents?: number;
@@ -29,6 +44,7 @@ interface ReplayTrackerOptions {
   consoleLevel?: LogLevel[];
   consoleLengthThreshold?: number;
   consoleStringLengthLimit?: number;
+  mutationThrottle?: ReplayMutationThrottleOptions;
 }
 declare class ReplayTracker {
   private readonly options;
@@ -43,43 +59,52 @@ declare class ReplayTracker {
   private readonly minReplayLengthMs;
   private readonly events;
   private readonly pending;
+  private readonly minLengthBlockedBatches;
   private queuedEventsSizeBytes;
   private pendingSizeBytes;
   private viewId;
+  private viewUrl;
   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;
+  private terminalFlushRequested;
+  private overflowed;
+  private readonly mutationThrottler;
   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;
   trackPageChange(url?: string): void;
-  onPageHidden(persisted?: boolean): void;
+  onPageHidden(persisted?: boolean, terminal?: boolean): void;
   onPageShow(persisted?: boolean): void;
   private beginRecording;
-  stop(): void;
+  stop(discard?: boolean): void;
   private onSessionRotated;
+  private applySessionRotation;
+  private resetSessionTiming;
   private onEvent;
   private onUnload;
+  private requestTerminalFlush;
   private hasReachedMinLength;
   private requestFlush;
   private scheduleMinLengthFlush;
@@ -88,10 +113,11 @@ declare class ReplayTracker {
   private createBatch;
   private eventSizeBytes;
   private batchSizeBytes;
-  private dropOldestPending;
+  private removePending;
   private enqueueBatch;
   private flush;
   private scheduleRetry;
+  private retryDelay;
   private sendBatch;
 }
 //#endregion

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

@@ -0,0 +1,201 @@
+//#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;
+const memorySessions = /* @__PURE__ */ new Map();
+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(siteKey) {
+	const memory = memorySessions.get(siteKey) ?? null;
+	const raw = getStorageItem("localStorage", `${SESSION_KEY}${siteKey}`);
+	if (!raw) return memory;
+	try {
+		const session = JSON.parse(raw);
+		return session.id ? session : memory;
+	} catch {}
+	return memory;
+}
+function writeSession(siteKey, session) {
+	if (!setStorageItem("localStorage", `${SESSION_KEY}${siteKey}`, JSON.stringify(session))) memorySessions.set(siteKey, session);
+}
+function clearSession(siteKey) {
+	memorySessions.delete(siteKey);
+	removeStorageItem("localStorage", `${SESSION_KEY}${siteKey}`);
+}
+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(siteKey, cookieless, touch) {
+	const now = Date.now();
+	if (cookieless) {
+		let session = memorySessions.get(siteKey);
+		if (!session) {
+			session = {
+				id: createId(),
+				start: now,
+				activity: now
+			};
+			memorySessions.set(siteKey, session);
+		} else if (touch) session.activity = now;
+		return {
+			session,
+			rotatedFrom: null
+		};
+	}
+	const existing = readSession(siteKey);
+	if (existing && !expired(existing, now)) {
+		if (touch) {
+			existing.activity = now;
+			writeSession(siteKey, existing);
+		}
+		return {
+			session: existing,
+			rotatedFrom: null
+		};
+	}
+	const session = {
+		id: createId(),
+		start: now,
+		activity: now
+	};
+	writeSession(siteKey, 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) {
+	if (cookielessMode === mode) return;
+	cookielessMode = mode;
+	memorySessions.clear();
+}
+function isCookielessMode() {
+	return cookielessMode;
+}
+function getSessionContext(siteKey, cookieless) {
+	const useCookieless = cookieless ?? cookielessMode;
+	const { session, rotatedFrom } = resolveSession(siteKey, 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(siteKey, 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(siteKey);
+	if (useCookieless) {
+		const now = Date.now();
+		memorySessions.set(siteKey, {
+			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

@@ -9,6 +9,7 @@ interface ErrorTrackingOptions {
   siteKey: string;
   baseUrl?: string;
   debug?: boolean;
+  trackHash?: boolean;
   flushInterval?: number;
   maxQueueSize?: number;
   sdkName?: string;
@@ -24,7 +25,7 @@ declare class ErrorTracker {
   constructor(options: ErrorTrackingOptions);
   private log;
   start(): void;
-  stop(): void;
+  stop(discard?: boolean): void;
   onPageHidden(persisted?: boolean): void;
   captureError(error: Error): void;
   private onError;

package/dist/error.js

@@ -1,2 +1,135 @@
-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-Dp2XNjRF.js";
+import { r as getSessionContext, t as sendData } from "./chunks/send-data-DR1JUXka.js";
+import { t as getAnonymousId } from "./chunks/identifiers-BvRNbiwA.js";
+//#region src/error.ts
+const SDK_NAME = "@faststats/web";
+const SDK_VERSION = "0.7.0";
+const EXTENSION_RE = /(?:^|\()(chrome|moz|ms-browser|safari-web)-extension:\/\//;
+function toEntry(kind, source, handled, fallback) {
+	if (source instanceof Error) return {
+		error: kind === "UnhandledRejection" ? kind : source.name.trim() || 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 isExtensionError(filename, source) {
+	const stack = source instanceof Error ? source.stack ?? "" : "";
+	return EXTENSION_RE.test(`${filename}\n${stack}`);
+}
+var ErrorTracker = class {
+	options;
+	endpoint;
+	queue = [];
+	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(discard = false) {
+		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;
+		if (discard) this.queue = [];
+		else this.flush();
+		this.log("Stopped");
+	}
+	onPageHidden(persisted = false) {
+		if (!persisted) 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"));
+	};
+	enqueue(error) {
+		const buildId = globalThis.__SOURCEMAPS_BUILD__?.buildId;
+		const userId = getAnonymousId(this.options.siteKey);
+		const ctx = getSessionContext(this.options.siteKey);
+		this.log("Captured:", error);
+		this.queue.push({
+			error,
+			context: {
+				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(this.options.trackHash ?? false),
+				properties: {}
+			}
+		});
+		if (this.queue.length >= (this.options.maxQueueSize ?? 50)) this.flush();
+	}
+	async flush() {
+		if (this.flushing || !this.queue.length) return;
+		this.flushing = true;
+		const batch = this.queue;
+		this.queue = [];
+		const groups = /* @__PURE__ */ new Map();
+		for (const item of batch) {
+			const key = JSON.stringify(item.context);
+			const group = groups.get(key) ?? {
+				context: item.context,
+				items: []
+			};
+			group.items.push(item);
+			groups.set(key, group);
+		}
+		const failed = await Promise.all([...groups.values()].map(async (group) => {
+			const errors = /* @__PURE__ */ new Map();
+			for (const { error } of group.items) {
+				const key = JSON.stringify(error);
+				const existing = errors.get(key);
+				if (existing) existing.count++;
+				else errors.set(key, {
+					...error,
+					count: 1
+				});
+			}
+			return await sendData({
+				url: this.endpoint,
+				data: JSON.stringify({
+					...group.context,
+					errors: [...errors.values()]
+				}),
+				debug: this.options.debug,
+				debugPrefix: "[ErrorTracker]"
+			}) ? [] : group.items;
+		}));
+		this.queue.unshift(...failed.flat());
+		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-Dp2XNjRF.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-BeC2XA4N.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;
 }