@faststats/web 0.12.1 → 0.13.1

package/dist/index.js

@@ -1,62 +1,6 @@
-import { a as sanitizeUrl, i as resolveBaseUrl, n as URLS, r as getPageContext, t as sendData } from "./chunks/send-data-gBIF6DTb.js";
-import { a as touchActivity, i as resetSession, n as getSessionContext, t as createId } from "./chunks/session-manager-DUpF3mi3.js";
-import { n as resetAnonymousId, t as getAnonymousId } from "./chunks/identifiers-DOtve3E5.js";
-//#region src/extensions.ts
-var ExtensionHost = class {
-	context;
-	log;
-	handlers = /* @__PURE__ */ new Map();
-	cleanups = [];
-	stopped = false;
-	constructor(extensions, context, log) {
-		this.context = context;
-		this.log = log;
-		for (const extension of extensions) this.setup(extension);
-	}
-	emit(hook, event) {
-		if (this.stopped) return;
-		for (const handler of this.handlers.get(hook) ?? []) try {
-			handler(event)?.catch((error) => this.log(`${hook} failed`, error));
-		} catch (error) {
-			this.log(`${hook} failed`, error);
-		}
-	}
-	stop(discard = false) {
-		if (this.stopped) return;
-		this.stopped = true;
-		for (const cleanup of this.cleanups.reverse()) try {
-			cleanup({ discard });
-		} catch (error) {
-			this.log("cleanup failed", error);
-		}
-		this.cleanups.length = 0;
-		this.handlers.clear();
-	}
-	async setup(extension) {
-		if (this.stopped) return;
-		const subscriptions = [];
-		try {
-			const cleanup = await extension.setup({
-				...this.context,
-				on: (hook, handler) => {
-					if (this.stopped) return () => {};
-					const handlers = this.handlers.get(hook) ?? /* @__PURE__ */ new Set();
-					this.handlers.set(hook, handlers);
-					handlers.add(handler);
-					const off = () => handlers.delete(handler);
-					subscriptions.push(off);
-					return off;
-				}
-			});
-			if (this.stopped) cleanup?.({ discard: true });
-			else if (cleanup) this.cleanups.push(cleanup);
-		} catch (error) {
-			for (const off of subscriptions) off();
-			this.log(`${extension.name} setup failed`, error);
-		}
-	}
-};
-//#endregion
+import { a as resolveBaseUrl, i as getPageContext, n as URLS, o as sanitizeUrl, r as getClientContext, s as ExtensionHost, t as sendData } from "./chunks/send-data-B7P3f5PT.js";
+import { a as touchActivity, i as resetSession, n as getSessionContext, t as createId } from "./chunks/session-manager-VM5RZj9H.js";
+import { n as resetAnonymousId, t as getAnonymousId } from "./chunks/identifiers-3X8XI1pD.js";
 //#region src/outbound-links.ts
 const DEDUPE_MS = 500;
 function outboundHref(event) {
@@ -88,43 +32,36 @@ function trackOutboundLinks(report) {
 //#endregion
 //#region src/analytics.ts
 const navigationListeners = /* @__PURE__ */ new Set();
-const historyPatches = {};
-function patchHistory(method) {
-	if (historyPatches[method]?.owner === history) return;
-	const original = history[method];
-	const wrapped = function(data, unused, url) {
-		Reflect.apply(original, this, [
-			data,
-			unused,
-			url
-		]);
-		for (const listener of navigationListeners) listener();
-	};
-	history[method] = wrapped;
-	historyPatches[method] = {
-		owner: history,
-		original,
-		wrapped
-	};
-}
+const historyPatches = /* @__PURE__ */ new Map();
 function observeHistory(listener) {
 	navigationListeners.add(listener);
-	patchHistory("pushState");
-	patchHistory("replaceState");
+	for (const method of ["pushState", "replaceState"]) {
+		if (historyPatches.get(method)?.target === history) continue;
+		const original = history[method];
+		const wrapped = function(...args) {
+			Reflect.apply(original, this, args);
+			for (const listener of navigationListeners) listener();
+		};
+		history[method] = wrapped;
+		historyPatches.set(method, {
+			target: history,
+			original,
+			wrapped
+		});
+	}
 	return () => {
 		navigationListeners.delete(listener);
 		if (navigationListeners.size) return;
-		for (const method of ["pushState", "replaceState"]) {
-			const patch = historyPatches[method];
-			if (patch && history[method] === patch.wrapped) {
-				history[method] = patch.original;
-				delete historyPatches[method];
-			}
+		for (const [method, patch] of historyPatches) {
+			if (history[method] !== patch.wrapped) continue;
+			history[method] = patch.original;
+			historyPatches.delete(method);
 		}
 	};
 }
 const RESERVED_EVENTS = /* @__PURE__ */ new Set([
 	"pageview",
+	"page_ping",
 	"page_leave",
 	"error",
 	"outbound_link"
@@ -189,8 +126,9 @@ var WebAnalytics = class {
 			context,
 			duration: 0,
 			startedAt: null,
-			checkedAt: Date.now(),
-			reportedDuration: -1
+			activeAt: Date.now(),
+			reportedDuration: 0,
+			beats: 0
 		};
 		this.send("pageview", {
 			...properties,
@@ -254,21 +192,19 @@ var WebAnalytics = class {
 	setConsentMode(mode) {
 		if (mode === this.consentMode) return;
 		const wasTracking = this.canTrack();
-		const wasCookieless = this.isCookieless();
-		const willTrack = mode !== "denied";
-		const willBeCookieless = this.options.cookieless === true || mode === "anonymous";
-		if (wasTracking && willTrack && wasCookieless !== willBeCookieless) this.leavePage();
+		const identityChanges = this.isCookieless() !== this.isCookieless(mode);
+		if (mode !== "denied" && identityChanges) this.leavePage();
 		this.consentMode = mode;
-		if (!willTrack) {
+		if (mode === "denied") {
 			this.leavePage();
 			this.pendingPageview = null;
 			this.stopExtensions(true);
-			return;
+		} else if (!wasTracking) {
+			if (this.state === "started") this.activate("consent");
+		} else {
+			this.extensions?.emit("consentChange", { cookieless: this.isCookieless() });
+			if (identityChanges) this.pageview({ trigger: "consent" });
 		}
-		if (wasTracking) {
-			this.extensions?.emit("consentChange", { cookieless: willBeCookieless });
-			if (wasCookieless !== willBeCookieless) this.pageview({ trigger: "consent" });
-		} else if (this.state === "started") this.activate("consent");
 	}
 	getAnonymousId() {
 		return this.canTrack() ? getAnonymousId(this.options.siteKey, this.isCookieless()) : "";
@@ -280,8 +216,8 @@ var WebAnalytics = class {
 	canTrack() {
 		return this.consentMode !== "denied";
 	}
-	isCookieless() {
-		return this.options.cookieless === true || this.consentMode === "anonymous";
+	isCookieless(mode = this.consentMode) {
+		return this.options.cookieless === true || mode === "anonymous";
 	}
 	isActive() {
 		return this.state === "started" && this.canTrack();
@@ -291,6 +227,7 @@ var WebAnalytics = class {
 	}
 	context(session = this.session()) {
 		return {
+			...getClientContext(),
 			...getPageContext(this.options.trackHash),
 			userId: this.getAnonymousId() || void 0,
 			sessionId: session.sessionId,
@@ -324,7 +261,7 @@ var WebAnalytics = class {
 		this.bind(window, "pagehide", this.onPageHide);
 		this.bind(window, "pageshow", this.onPageShow);
 		this.bind(window, "focus", this.onResume);
-		this.bind(window, "blur", () => this.pauseVisit());
+		this.bind(window, "blur", this.onBlur);
 		this.bind(window, "popstate", this.onNavigate);
 		for (const type of [
 			"pointerdown",
@@ -341,7 +278,6 @@ var WebAnalytics = class {
 	}
 	onNavigate = () => this.pageview({ trigger: "navigation" });
 	onVisibilityChange = () => {
-		if (!this.canTrack()) return;
 		if (document.visibilityState === "hidden") {
 			this.pauseVisit();
 			this.extensions?.emit("pageHide", {
@@ -353,17 +289,15 @@ var WebAnalytics = class {
 		this.onResume();
 	};
 	onPageHide = (event) => {
-		if (!this.canTrack()) return;
 		const persisted = event.persisted;
-		this.pauseVisit();
+		if (persisted) this.pauseVisit();
+		else this.leavePage();
 		this.extensions?.emit("pageHide", {
 			persisted,
 			terminal: !persisted
 		});
-		if (!persisted) this.leavePage();
 	};
 	onPageShow = (event) => {
-		if (!this.canTrack()) return;
 		this.onResume();
 		this.extensions?.emit("pageShow", { persisted: event.persisted });
 	};
@@ -371,6 +305,13 @@ var WebAnalytics = class {
 		this.pageview(this.pendingPageview ?? { trigger: "session" });
 		this.resumeVisit();
 	};
+	onBlur = () => {
+		const visit = this.visit;
+		const blurredAt = performance.now();
+		setTimeout(() => {
+			if (this.visit === visit && !document.hasFocus()) this.pauseVisit(false, blurredAt);
+		});
+	};
 	onActivity = () => {
 		this.lastInputAt = performance.now();
 		if (this.visit?.startedAt === null && document.hasFocus()) this.onResume();
@@ -378,47 +319,44 @@ var WebAnalytics = class {
 	isIdle() {
 		const now = performance.now();
 		if (now - this.lastInputAt < IDLE_MS) return false;
-		const playing = [...document.querySelectorAll("video,audio")].some((media) => !media.paused && !media.ended);
-		if (playing) this.lastInputAt = now;
-		return !playing;
+		const engaged = document.activeElement?.tagName === "IFRAME" || [...document.querySelectorAll("video,audio")].some((media) => !media.paused && !media.ended);
+		if (engaged) this.lastInputAt = now;
+		return !engaged;
 	}
 	leavePage() {
-		this.pauseVisit();
+		this.pauseVisit(true);
 		this.visit = null;
 	}
-	checkpoint() {
+	checkpoint(leaving = false, periodic = false, now = performance.now()) {
 		const visit = this.visit;
 		if (!visit || !this.isActive()) return;
-		let activeAt = visit.checkedAt;
 		if (visit.startedAt !== null) {
-			const now = performance.now();
-			if (now - visit.startedAt < IDLE_MS) {
-				const active = Math.min(now, this.lastInputAt + IDLE_MS) - visit.startedAt;
-				visit.duration += active;
-				activeAt += active;
+			const activeUntil = Math.min(now, this.lastInputAt + IDLE_MS);
+			if (now - visit.startedAt < IDLE_MS && activeUntil > visit.startedAt) {
+				visit.duration += activeUntil - visit.startedAt;
+				visit.activeAt = Date.now() - (performance.now() - activeUntil);
 			}
 			visit.startedAt = now;
-			visit.checkedAt = Date.now();
 		}
+		if (periodic && ++visit.beats !== 1 && visit.beats % 4 !== 3) return;
 		const duration = Math.round(visit.duration);
-		if (duration === visit.reportedDuration) return;
+		if (!leaving && duration === visit.reportedDuration) return;
 		visit.reportedDuration = duration;
-		this.send("page_leave", {
+		this.send(leaving ? "page_leave" : "page_ping", {
 			visit_id: visit.id,
 			time_on_page: duration,
-			session_duration: Math.max(0, activeAt - visit.session.sessionStart)
+			session_duration: Math.max(0, visit.activeAt - visit.session.sessionStart)
 		}, visit.context);
 	}
-	pauseVisit() {
+	pauseVisit(leaving = false, at) {
 		if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
 		this.heartbeatTimer = null;
-		this.checkpoint();
+		this.checkpoint(leaving, false, at);
 		if (this.visit) this.visit.startedAt = null;
 	}
 	resumeVisit() {
 		if (!this.isActive() || !this.visit || this.visit.startedAt !== null || document.visibilityState !== "visible" || !document.hasFocus()) return;
 		this.visit.startedAt = this.lastInputAt = performance.now();
-		this.visit.checkedAt = Date.now();
 		this.heartbeatTimer = setInterval(() => {
 			if (document.visibilityState !== "visible" || !document.hasFocus() || this.isIdle()) {
 				this.pauseVisit();
@@ -426,12 +364,15 @@ var WebAnalytics = class {
 			}
 			const visit = this.visit;
 			this.pageview({ trigger: "session" });
-			if (this.visit === visit) this.checkpoint();
+			if (this.visit === visit) this.checkpoint(false, true);
 		}, 15e3);
 	}
 	send(event, properties = {}, context) {
 		if (!this.isActive()) return;
-		context ??= this.context();
+		context ??= {
+			...this.context(),
+			visit_id: this.visit?.id
+		};
 		let data;
 		try {
 			data = JSON.stringify({

package/dist/replay.d.ts

@@ -57,81 +57,54 @@ export type SessionReplayExtensionOptions = Omit<ReplayTrackerOptions, "siteKey"
 export declare function sessionReplay(options?: SessionReplayExtensionOptions): AnalyticsExtension;
 export default class ReplayTracker {
   private readonly options;
-  private readonly endpoint;
-  private readonly compress;
-  private readonly flushInterval;
-  private readonly maxEvents;
-  private readonly maxBatchSizeBytes;
-  private readonly maxLowLatencyBatchSizeBytes;
-  private readonly maxPendingBatches;
-  private readonly maxQueueSizeBytes;
-  private readonly minReplayLengthMs;
-  private readonly events;
-  private readonly pending;
-  private queuedEventsSizeBytes;
-  private pendingSizeBytes;
-  private viewId;
-  private viewUrl;
-  private chunkStartedAt;
+  private readonly limits;
+  private readonly uploader;
+  private readonly throttler;
+  private cookieless;
   private started;
-  private disposed;
-  private startTime;
-  private intervalId;
-  private flushTask;
-  private retryTask;
-  private retryAttempt;
-  private minLengthFlushTask;
+  private overflowed;
   private stopRecording?;
-  private activeSessionId;
-  private sending;
-  private queuedFlush;
-  private unsubscribeRotation?;
-  private lastCookielessMode;
-  private needsFinalization;
-  private initialFlushPending;
+  private stopFollowing?;
+  private intervalTimer?;
+  private flushTimer?;
+  private minLengthTimer?;
+  private viewId;
+  private viewUrl;
+  private session;
+  private streamStart;
+  private chunkStart;
+  private sequence;
+  private events;
+  private eventBytes;
   private resumed;
-  private overflowed;
-  private replayEventSequence;
-  private readonly mutationThrottler;
+  private unfinalized;
   constructor(options: ReplayTrackerOptions);
-  private log;
-  private sessionContext;
-  private sanitize;
-  private clearFlushTimers;
-  private dropEvents;
-  private clearQueues;
-  private finalizeSession;
-  setCookielessMode(cookieless: boolean): void;
   start(): void;
+  stop(discard?: boolean): void;
+  /** Nothing captured under the old identity may be sent under the new one. */
+  setCookielessMode(cookieless: boolean): void;
   trackPageChange(url?: string): void;
   onPageHidden(persisted?: boolean, terminal?: boolean): void;
   onPageShow(persisted?: boolean): void;
-  private recordingPlugins;
+  private log;
+  private sanitize;
+  private currentSession;
+  private followSession;
   private beginRecording;
-  stop(discard?: boolean): void;
-  private onSessionRotated;
-  private subscribeToSessionRotation;
-  private applySessionRotation;
-  private beginReplayStream;
-  private resetSessionTiming;
-  private onEvent;
-  private requestTerminalFlush;
-  private hasReachedMinLength;
-  private requestFlush;
-  private scheduleMinLengthFlush;
-  private enqueueEventsIfReady;
-  private takeEventBatches;
-  private createBatch;
-  private eventSizeBytes;
-  private batchSizeBytes;
-  private removePending;
+  private recordingPlugins;
+  private takeFullSnapshot;
   private stopCapture;
-  private enqueueBatch;
+  private readonly onEvent;
+  private beginStream;
+  private rotate;
+  private reachedMinLength;
+  private dropEvents;
+  private requestFlush;
   private flush;
-  private sendPending;
-  private scheduleRetry;
-  private retryDelay;
-  private sendBatch;
+  private finish;
+  private batchEvents;
+  private endStream;
+  private enqueue;
 }
 //#endregion
 export {};