@faststats/web 0.11.0 → 0.12.0

package/README.md

@@ -5,8 +5,8 @@
 
 The base SDK handles analytics, identity, sessions, navigation, outbound link
 clicks, and consent.
-Error tracking, Web Vitals, and session replay are independent extensions, so
-applications only download the products they use.
+Error tracking, Web Vitals, session replay, and feature flags are independent
+extensions, so applications only download the products they use.
 
 ```ts
 import { init, track } from "@faststats/web";
@@ -77,6 +77,55 @@ since the last delivered checkpoint. The collector must accept successive events
 for the same visitor and URL; deploy the removal of its five-second debounce
 before releasing this SDK.
 
+### Feature flags
+
+`featureFlags()` loads the project's flags for the visitor the client tracks and
+resolves them synchronously from memory:
+
+```ts
+import { init } from "@faststats/web";
+import { featureFlags } from "@faststats/web/flags";
+
+const flags = featureFlags({ flags: ["new-checkout", "max-uploads"] });
+init({ siteKey: "site_123", extensions: [flags] });
+
+await flags.ready();
+if (flags.isEnabled("new-checkout")) showNewCheckout();
+const maxUploads = flags.get("max-uploads", 10);
+```
+
+Every loaded flag is recorded as an exposure, whether or not the app reads it,
+so list the keys the app uses in `flags`. Without it every flag in the project
+is loaded.
+
+Flags are evaluated for the anonymous visitor ID, and the session ID links each
+evaluation to analytics. `identify()` re-evaluates them for that user, so
+rollouts follow the user across devices, and `logout()` goes back to a new
+anonymous visitor. When the user is known at startup, pass `userId` to skip the
+anonymous load. A cookieless visitor has no lasting ID, so rollouts hold for the
+session only. Flags are not loaded while consent is `"denied"`.
+
+`get()` returns the default passed at the call site while flags are loading, and
+when the flag does not exist, is archived, has a different type, or the service
+cannot be reached within `timeoutMs`. `details(key)` adds the variant and reason
+(`rule_match`, `target_match`, `fallthrough`, `disabled`,
+`prerequisite_failed`).
+
+```ts
+flags.subscribe(() => render(flags.status)); // "idle" | "loading" | "ready" | "error"
+await flags.setContext({ attributes: { plan: "pro" } });
+await flags.reload();
+```
+
+| Option       |                                                          |
+| ------------ | -------------------------------------------------------- |
+| `flags`      | The flag keys to load.                                   |
+| `userId`     | Your ID for a signed-in user, when known at startup.     |
+| `attributes` | Anything targeting rules should match on.                |
+| `endpoint`   | Base URL of the flags service, when self-run.            |
+| `timeoutMs`  | Aborts a slower load. Defaults to `3000`.                |
+| `fetch`      | A `fetch` implementation to use instead of the global.   |
+
 ### Network recording in session replay
 
 Network recording is disabled by default. Enable it with

package/dist/chunks/{extensions-DZDQn8O8.d.ts → extensions-BfubKIzk.d.ts}

@@ -13,6 +13,10 @@ type ExtensionHooks = {
   consentChange: {
     cookieless: boolean;
   };
+  /** `identify()` set a user, or `logout()` cleared one. */
+  identityChange: {
+    userId: string | undefined;
+  };
   error: {
     error: Error;
   };

package/dist/chunks/{identifiers-BwGNL11R.js → identifiers-CpmDmpDv.js}

@@ -1,4 +1,4 @@
-import { c as removeStorageItem, l as setStorageItem, n as createId, s as getStorageItem } from "./send-data-D520oab1.js";
+import { c as setStorageItem, o as getStorageItem, s as removeStorageItem, t as createId } from "./session-manager-CFQEWbgo.js";
 //#region src/utils/identifiers.ts
 const ANONYMOUS_ID_KEY = "faststats_anon_id_";
 function getAnonymousId(siteKey, cookieless = false) {

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

@@ -0,0 +1,84 @@
+//#region src/utils/api-urls.ts
+function resolveBaseUrl(baseUrl) {
+	return baseUrl?.replace(/\/+$/, "") || "https://metrics.faststats.dev";
+}
+const URLS = {
+	events: "/v1/web",
+	identify: "/v1/identify",
+	replay: "/v1/replay",
+	vitals: "/v1/vitals"
+};
+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 getReferrer() {
+	const raw = document.referrer;
+	if (!raw) return null;
+	try {
+		const pageOrigin = new URL(location.href).origin;
+		if (new URL(raw, location.href).origin === pageOrigin) return null;
+	} catch {}
+	return sanitizeUrl(raw);
+}
+function getPageContext(includeHash = false) {
+	const hash = includeHash ? location.hash : "";
+	const ctx = {
+		page: `${location.pathname}${hash}`,
+		url: sanitizeUrl(location.href, includeHash),
+		referrer: getReferrer(),
+		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
+//#region src/utils/send-data.ts
+async function sendData(options) {
+	const { url, data, contentType = "application/json", debug = false, debugPrefix = "[Analytics]", useBeacon = true, keepalive = true, settleRejected } = options;
+	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 {}
+	const size = typeof data === "string" ? data.length : data instanceof Blob ? data.size : data.byteLength;
+	const post = (keepalive) => fetch(url, {
+		method: "POST",
+		body: data,
+		headers: { "Content-Type": contentType },
+		keepalive,
+		credentials: "omit"
+	});
+	try {
+		const useKeepalive = keepalive && size <= 61440;
+		const { ok, status } = await post(useKeepalive).catch((error) => {
+			if (!useKeepalive) throw error;
+			return post(false);
+		});
+		if (debug) console.log(debugPrefix, ok ? "Sent via fetch" : status);
+		return ok || !!settleRejected && status < 500 && status !== 429;
+	} catch {
+		if (debug) console.log(debugPrefix, "Failed to send");
+		return false;
+	}
+}
+//#endregion
+export { sanitizeUrl as a, resolveBaseUrl as i, URLS as n, getPageContext as r, sendData as t };

package/dist/chunks/{send-data-D520oab1.js → session-manager-CFQEWbgo.js}

@@ -1,54 +1,3 @@
-//#region src/utils/api-urls.ts
-function resolveBaseUrl(baseUrl) {
-	return baseUrl?.replace(/\/+$/, "") || "https://metrics.faststats.dev";
-}
-const URLS = {
-	events: "/v1/web",
-	identify: "/v1/identify",
-	replay: "/v1/replay",
-	vitals: "/v1/vitals"
-};
-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 getReferrer() {
-	const raw = document.referrer;
-	if (!raw) return null;
-	try {
-		const pageOrigin = new URL(location.href).origin;
-		if (new URL(raw, location.href).origin === pageOrigin) return null;
-	} catch {}
-	return sanitizeUrl(raw);
-}
-function getPageContext(includeHash = false) {
-	const hash = includeHash ? location.hash : "";
-	const ctx = {
-		page: `${location.pathname}${hash}`,
-		url: sanitizeUrl(location.href, includeHash),
-		referrer: getReferrer(),
-		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
 //#region src/utils/storage.ts
 function getStorageItem(name, key) {
 	try {
@@ -200,31 +149,4 @@ function onSessionRotated(siteKey, cookieless, listener) {
 	};
 }
 //#endregion
-//#region src/utils/send-data.ts
-async function sendData(options) {
-	const { url, data, contentType = "application/json", debug = false, debugPrefix = "[Analytics]", useBeacon = true, keepalive = true, settleRejected } = options;
-	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 {}
-	const size = typeof data === "string" ? data.length : data instanceof Blob ? data.size : data.byteLength;
-	try {
-		const { ok, status } = await fetch(url, {
-			method: "POST",
-			body: data,
-			headers: { "Content-Type": contentType },
-			keepalive: keepalive && size <= 61440,
-			credentials: "omit"
-		});
-		if (debug) console.log(debugPrefix, ok ? "Sent via fetch" : status);
-		return ok || !!settleRejected && status < 500 && status !== 429;
-	} catch {
-		if (debug) console.log(debugPrefix, "Failed to send");
-		return false;
-	}
-}
-//#endregion
-export { resetSession as a, removeStorageItem as c, getPageContext as d, resolveBaseUrl as f, onSessionRotated as i, setStorageItem as l, createId as n, touchActivity as o, sanitizeUrl as p, getSessionContext as r, getStorageItem as s, sendData as t, URLS as u };
+export { touchActivity as a, setStorageItem as c, resetSession as i, getSessionContext as n, getStorageItem as o, onSessionRotated as r, removeStorageItem as s, createId as t };

package/dist/error.d.ts

@@ -1,4 +1,4 @@
-import { t as AnalyticsExtension } from "./chunks/extensions-DZDQn8O8.js";
+import { t as AnalyticsExtension } from "./chunks/extensions-BfubKIzk.js";
 //#region src/error.d.ts
 export type ErrorEntry = {
   error: string;

package/dist/error.js

@@ -1,8 +1,9 @@
-import { d as getPageContext, f as resolveBaseUrl, r as getSessionContext, t as sendData, u as URLS } from "./chunks/send-data-D520oab1.js";
-import { t as getAnonymousId } from "./chunks/identifiers-BwGNL11R.js";
+import { i as resolveBaseUrl, n as URLS, r as getPageContext, t as sendData } from "./chunks/send-data-DYZZjeM-.js";
+import { n as getSessionContext } from "./chunks/session-manager-CFQEWbgo.js";
+import { t as getAnonymousId } from "./chunks/identifiers-CpmDmpDv.js";
 //#region src/error.ts
 const SDK_NAME = "@faststats/web";
-const SDK_VERSION = "0.11.0";
+const SDK_VERSION = "0.12.0";
 function errorTracking(options = {}) {
 	return {
 		name: "error-tracking",

package/dist/flags.d.ts

@@ -0,0 +1,79 @@
+import { n as AnalyticsExtensionContext, r as ExtensionCleanup, t as AnalyticsExtension } from "./chunks/extensions-BfubKIzk.js";
+//#region src/flags.d.ts
+export interface FeatureFlagsOptions {
+  /**
+   * Flag keys this app reads. Every loaded flag is recorded as an exposure,
+   * so list them to keep flags the app never shows out of analytics.
+   * Loads every flag when omitted.
+   */
+  flags?: string[];
+  /** Your own ID for a signed-in user. Rollouts follow it across devices. */
+  userId?: string;
+  /** Anything targeting rules should match on. */
+  attributes?: Record<string, unknown>;
+  /** Base URL of the feature flags service. */
+  endpoint?: string;
+  /** Aborts a load that takes longer, so flags serve their defaults. */
+  timeoutMs?: number;
+  fetch?: typeof fetch;
+}
+export type FeatureFlagReason = "disabled" | "prerequisite_failed" | "target_match" | "rule_match" | "fallthrough";
+export interface FeatureFlagResult {
+  value: unknown;
+  variant: string;
+  reason: FeatureFlagReason;
+}
+export interface FeatureFlagsContext {
+  /** Pass `null` to go back to the anonymous visitor. */
+  userId?: string | null;
+  /** Replaces the attributes set before. */
+  attributes?: Record<string, unknown>;
+}
+/**
+ * `idle` until the client starts tracking, `loading` during the first load
+ * for a visitor, then `ready`, or `error` when that load failed.
+ */
+export type FeatureFlagsStatus = "idle" | "loading" | "ready" | "error";
+/**
+ * Loads flags from the FastStats flags service for the visitor the analytics
+ * client tracks and resolves them synchronously from memory.
+ */
+export declare class FeatureFlags implements AnalyticsExtension {
+  private readonly options;
+  readonly name = "feature-flags";
+  private readonly listeners;
+  private context;
+  private results;
+  private currentStatus;
+  private latestLoad;
+  private subjectKey;
+  private loading;
+  private userId;
+  private attributes;
+  constructor(options?: FeatureFlagsOptions);
+  setup(context: AnalyticsExtensionContext): ExtensionCleanup;
+  get status(): FeatureFlagsStatus;
+  /**
+   * The flag's value, or `defaultValue` while flags are loading, when the flag
+   * does not exist or is archived, or when its type differs from the default's.
+   */
+  get(key: string, defaultValue: boolean): boolean;
+  get(key: string, defaultValue: string): string;
+  get(key: string, defaultValue: number): number;
+  get<T>(key: string, defaultValue: T): T;
+  isEnabled(key: string): boolean;
+  details(key: string): FeatureFlagResult | undefined;
+  /** Changes who flags are evaluated for and loads them again. */
+  setContext(context: FeatureFlagsContext): Promise<void>;
+  /** Resolves once the load in flight settles. Never rejects. */
+  ready(): Promise<void>;
+  /** Loads the flags again. Never rejects; a failed load sets `status`. */
+  reload(): Promise<void>;
+  /** Calls `listener` whenever the flags or `status` change. */
+  subscribe(listener: () => void): () => void;
+  private subject;
+  private evaluate;
+  private update;
+}
+export declare function featureFlags(options?: FeatureFlagsOptions): FeatureFlags;
+//#endregion

package/dist/flags.js

@@ -0,0 +1,145 @@
+import { n as getSessionContext } from "./chunks/session-manager-CFQEWbgo.js";
+import { t as getAnonymousId } from "./chunks/identifiers-CpmDmpDv.js";
+//#region src/flags.ts
+const DEFAULT_ENDPOINT = "https://flags.faststats.dev";
+const DEFAULT_TIMEOUT_MS = 3e3;
+/**
+* Loads flags from the FastStats flags service for the visitor the analytics
+* client tracks and resolves them synchronously from memory.
+*/
+var FeatureFlags = class {
+	options;
+	name = "feature-flags";
+	listeners = /* @__PURE__ */ new Set();
+	context = null;
+	results = {};
+	currentStatus = "idle";
+	latestLoad = 0;
+	subjectKey = "";
+	loading = null;
+	userId;
+	attributes;
+	constructor(options = {}) {
+		this.options = options;
+		this.userId = options.userId;
+		this.attributes = options.attributes;
+	}
+	setup(context) {
+		this.context = context;
+		context.on("identityChange", ({ userId }) => {
+			this.userId = userId;
+			this.reload();
+		});
+		context.on("consentChange", () => void this.reload());
+		this.reload();
+		return () => {
+			if (this.context !== context) return;
+			this.context = null;
+			this.latestLoad++;
+			this.loading = null;
+			this.subjectKey = "";
+			this.update({}, "idle");
+		};
+	}
+	get status() {
+		return this.currentStatus;
+	}
+	get(key, defaultValue) {
+		const result = this.details(key);
+		if (!result) return defaultValue;
+		const type = typeof defaultValue;
+		if ((type === "boolean" || type === "string" || type === "number") && typeof result.value !== type) return defaultValue;
+		return result.value;
+	}
+	isEnabled(key) {
+		return this.get(key, false);
+	}
+	details(key) {
+		return Object.hasOwn(this.results, key) ? this.results[key] : void 0;
+	}
+	/** Changes who flags are evaluated for and loads them again. */
+	setContext(context) {
+		if (context.userId !== void 0) this.userId = context.userId?.trim() || void 0;
+		if (context.attributes) this.attributes = context.attributes;
+		return this.reload();
+	}
+	/** Resolves once the load in flight settles. Never rejects. */
+	ready() {
+		return this.loading ?? Promise.resolve();
+	}
+	/** Loads the flags again. Never rejects; a failed load sets `status`. */
+	reload() {
+		const context = this.context;
+		if (!context) return Promise.resolve();
+		const load = ++this.latestLoad;
+		const subject = this.subject(context);
+		if (subject.key !== this.subjectKey) {
+			this.subjectKey = subject.key;
+			this.update({}, "loading");
+		}
+		const loading = this.evaluate(context, subject.body).then((results) => {
+			if (load === this.latestLoad) this.update(results, "ready");
+		}, (error) => {
+			if (context.debug) console.log("[FastStats] flags failed", error);
+			if (load !== this.latestLoad) return;
+			if (this.currentStatus === "loading") this.update({}, "error");
+		}).finally(() => {
+			if (this.loading === loading) this.loading = null;
+		});
+		this.loading = loading;
+		return loading;
+	}
+	/** Calls `listener` whenever the flags or `status` change. */
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	subject(context) {
+		const cookieless = context.isCookieless();
+		const { sessionId } = getSessionContext(context.siteKey, cookieless);
+		const identifier = getAnonymousId(context.siteKey, cookieless) || sessionId;
+		return {
+			key: JSON.stringify([identifier, this.userId]),
+			body: {
+				identifier,
+				userId: this.userId,
+				sessionId,
+				attributes: this.attributes ?? {},
+				flags: this.options.flags && [...new Set(this.options.flags)]
+			}
+		};
+	}
+	async evaluate(context, body) {
+		const endpoint = (this.options.endpoint ?? DEFAULT_ENDPOINT).replace(/\/+$/, "");
+		const response = await (this.options.fetch ?? fetch)(`${endpoint}/v1/evaluate`, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				authorization: `Bearer ${context.siteKey}`
+			},
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+			cache: "no-store"
+		});
+		if (!response.ok) throw new Error(`Evaluation failed with status ${response.status}`);
+		const data = await response.json();
+		if (typeof data?.flags !== "object" || data.flags === null) throw new Error("Unexpected response from the flags service");
+		return data.flags;
+	}
+	update(results, status) {
+		this.results = results;
+		this.currentStatus = status;
+		for (const listener of [...this.listeners]) try {
+			listener();
+		} catch (error) {
+			if (this.context?.debug) console.log("[FastStats] flags listener failed", error);
+		}
+	}
+};
+function featureFlags(options = {}) {
+	return new FeatureFlags(options);
+}
+//#endregion
+export { FeatureFlags, featureFlags };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { a as ExtensionHook, i as ExtensionHandler, n as AnalyticsExtensionContext, o as ExtensionHooks, r as ExtensionCleanup, t as AnalyticsExtension } from "./chunks/extensions-DZDQn8O8.js";
+import { a as ExtensionHook, i as ExtensionHandler, n as AnalyticsExtensionContext, o as ExtensionHooks, r as ExtensionCleanup, t as AnalyticsExtension } from "./chunks/extensions-BfubKIzk.js";
 //#region src/analytics.d.ts
 type ConsentMode = "anonymous" | "granted" | "denied";
 interface IdentifyOptions {

package/dist/index.js

@@ -1,5 +1,6 @@
-import { a as resetSession, d as getPageContext, f as resolveBaseUrl, n as createId, o as touchActivity, p as sanitizeUrl, r as getSessionContext, t as sendData, u as URLS } from "./chunks/send-data-D520oab1.js";
-import { n as resetAnonymousId, t as getAnonymousId } from "./chunks/identifiers-BwGNL11R.js";
+import { a as sanitizeUrl, i as resolveBaseUrl, n as URLS, r as getPageContext, t as sendData } from "./chunks/send-data-DYZZjeM-.js";
+import { a as touchActivity, i as resetSession, n as getSessionContext, t as createId } from "./chunks/session-manager-CFQEWbgo.js";
+import { n as resetAnonymousId, t as getAnonymousId } from "./chunks/identifiers-CpmDmpDv.js";
 //#region src/extensions.ts
 var ExtensionHost = class {
 	context;
@@ -213,6 +214,7 @@ var WebAnalytics = class {
 		} : userOrExternalId;
 		const externalId = user.id.trim();
 		if (!externalId) return false;
+		this.extensions?.emit("identityChange", { userId: externalId });
 		const clearFields = [
 			"email",
 			"name",
@@ -246,6 +248,7 @@ var WebAnalytics = class {
 		this.leavePage();
 		if (resetAnonymousIdentity) resetAnonymousId(this.options.siteKey, this.isCookieless());
 		resetSession(this.options.siteKey, this.isCookieless());
+		this.extensions?.emit("identityChange", { userId: void 0 });
 		this.pageview({ trigger: "logout" });
 	}
 	setConsentMode(mode) {

package/dist/replay.d.ts

@@ -1,8 +1,8 @@
-import { t as AnalyticsExtension } from "./chunks/extensions-DZDQn8O8.js";
+import { t as AnalyticsExtension } from "./chunks/extensions-BfubKIzk.js";
 import { record } from "@rrweb/record";
 import { LogLevel } from "@rrweb/rrweb-plugin-console-record";
 import { NetworkRecordOptions } from "@rrweb/rrweb-plugin-network-record";
-//#region ../../node_modules/.bun/@rrweb+types@2.1.6/node_modules/@rrweb/types/dist/index.d.ts
+//#region ../../node_modules/.bun/@rrweb+types@2.1.7/node_modules/@rrweb/types/dist/index.d.ts
 declare global {
   interface Window {
     FontFace: typeof FontFace;
@@ -58,7 +58,7 @@ export declare function sessionReplay(options?: SessionReplayExtensionOptions):
 export default class ReplayTracker {
   private readonly options;
   private readonly endpoint;
-  private readonly compressionSupported;
+  private readonly compress;
   private readonly flushInterval;
   private readonly maxEvents;
   private readonly maxBatchSizeBytes;
@@ -95,6 +95,8 @@ export default class ReplayTracker {
   private readonly mutationThrottler;
   constructor(options: ReplayTrackerOptions);
   private log;
+  private sessionContext;
+  private sanitize;
   private clearFlushTimers;
   private dropEvents;
   private clearQueues;

package/dist/replay.js

@@ -1,5 +1,6 @@
-import { f as resolveBaseUrl, i as onSessionRotated, l as setStorageItem, n as createId, o as touchActivity, p as sanitizeUrl, r as getSessionContext, s as getStorageItem, t as sendData, u as URLS } from "./chunks/send-data-D520oab1.js";
-import { t as getAnonymousId } from "./chunks/identifiers-BwGNL11R.js";
+import { a as sanitizeUrl, i as resolveBaseUrl, n as URLS, t as sendData } from "./chunks/send-data-DYZZjeM-.js";
+import { a as touchActivity, c as setStorageItem, n as getSessionContext, o as getStorageItem, r as onSessionRotated, t as createId } from "./chunks/session-manager-CFQEWbgo.js";
+import { t as getAnonymousId } from "./chunks/identifiers-CpmDmpDv.js";
 import { record } from "@rrweb/record";
 import { getRecordConsolePlugin } from "@rrweb/rrweb-plugin-console-record";
 import { getRecordNetworkPlugin } from "@rrweb/rrweb-plugin-network-record";
@@ -95,7 +96,8 @@ function nextReplaySequence(siteKey, context, cookieless) {
 const MAX_TIMEOUT_MS = 2147483647;
 const DEFAULT_MAX_QUEUE_SIZE_BYTES = 2097152;
 const DEFAULT_MAX_BATCH_SIZE_BYTES = 921600;
-const DEFAULT_MAX_LOW_LATENCY_BATCH_SIZE_BYTES = 61440;
+const KEEPALIVE_LIMIT_BYTES = 61440;
+const DEFAULT_MAX_LOW_LATENCY_BATCH_SIZE_BYTES = 57344;
 const RETRY_BASE_DELAY_MS = 2e3;
 const RETRY_MAX_ATTEMPTS = 5;
 const RETRY_COOLDOWN_MS = 3e5;
@@ -104,7 +106,12 @@ const RRWEB_EVENT_FULL_SNAPSHOT = 2;
 const RRWEB_EVENT_META = 4;
 const REPLAY_SEQUENTIAL_ID_KEY = "_faststatsSeqId";
 const textEncoder = new TextEncoder();
+const eventSizeCache = /* @__PURE__ */ new WeakMap();
 const batchSizeCache = /* @__PURE__ */ new WeakMap();
+async function gzip(json) {
+	const stream = new Blob([json]).stream().pipeThrough(new CompressionStream("gzip"));
+	return new Uint8Array(await new Response(stream).arrayBuffer());
+}
 function boundedInteger(value, fallback, min, max) {
 	if (value === void 0 || !Number.isFinite(value) || value < min) return fallback;
 	return Math.min(Math.trunc(value), max);
@@ -133,7 +140,7 @@ function sessionReplay(options = {}) {
 var ReplayTracker = class {
 	options;
 	endpoint;
-	compressionSupported = typeof window !== "undefined" && "CompressionStream" in window;
+	compress;
 	flushInterval;
 	maxEvents;
 	maxBatchSizeBytes;
@@ -172,7 +179,8 @@ var ReplayTracker = class {
 		this.options = options;
 		this.lastCookielessMode = options.cookieless ?? false;
 		this.endpoint = `${resolveBaseUrl(options.baseUrl)}${URLS.replay}`;
-		this.flushInterval = boundedInteger(options.flushInterval, 15e3, 1, MAX_TIMEOUT_MS);
+		this.compress = (options.compress ?? true) && typeof window !== "undefined" && "CompressionStream" in window;
+		this.flushInterval = boundedInteger(options.flushInterval, 5e3, 1, MAX_TIMEOUT_MS);
 		this.maxEvents = boundedInteger(options.maxEvents, 1e3, 1, 1e5);
 		this.maxBatchSizeBytes = boundedInteger(options.maxBatchSizeBytes, DEFAULT_MAX_BATCH_SIZE_BYTES, 1, 33554432);
 		this.maxLowLatencyBatchSizeBytes = boundedInteger(options.maxLowLatencyBatchSizeBytes, DEFAULT_MAX_LOW_LATENCY_BATCH_SIZE_BYTES, 1, DEFAULT_MAX_LOW_LATENCY_BATCH_SIZE_BYTES);
@@ -184,6 +192,12 @@ var ReplayTracker = class {
 	log(...args) {
 		if (this.options.debug) console.log("[Replay]", ...args);
 	}
+	sessionContext() {
+		return getSessionContext(this.options.siteKey, this.lastCookielessMode);
+	}
+	sanitize(url) {
+		return sanitizeUrl(url, this.options.trackHash ?? false);
+	}
 	clearFlushTimers() {
 		if (this.flushTask) clearTimeout(this.flushTask);
 		if (this.retryTask) clearTimeout(this.retryTask);
@@ -214,7 +228,7 @@ var ReplayTracker = class {
 		if (this.started) this.subscribeToSessionRotation();
 		this.clearQueues();
 		this.clearFlushTimers();
-		const context = getSessionContext(this.options.siteKey, this.lastCookielessMode);
+		const context = this.sessionContext();
 		this.activeSessionId = context.sessionId;
 		this.resetSessionTiming(context);
 		this.beginReplayStream();
@@ -227,8 +241,8 @@ var ReplayTracker = class {
 		this.overflowed = false;
 		this.replayEventSequence = 0;
 		this.viewId = createId();
-		this.viewUrl = sanitizeUrl(window.location.href, this.options.trackHash ?? false);
-		const context = getSessionContext(this.options.siteKey, this.lastCookielessMode);
+		this.viewUrl = this.sanitize(window.location.href);
+		const context = this.sessionContext();
 		this.activeSessionId = context.sessionId;
 		this.resetSessionTiming(context);
 		this.subscribeToSessionRotation();
@@ -239,7 +253,7 @@ var ReplayTracker = class {
 	trackPageChange(url) {
 		if (!this.started) return;
 		this.viewId = createId();
-		const href = sanitizeUrl(url ?? window.location.href, this.options.trackHash ?? false);
+		const href = this.sanitize(url ?? window.location.href);
 		this.viewUrl = href;
 		this.onEvent({
 			type: VIEW_META_EVENT_TYPE,
@@ -351,12 +365,7 @@ var ReplayTracker = class {
 			this.log("Recording discarded");
 			return;
 		}
-		if (!this.hasReachedMinLength()) {
-			this.dropEvents();
-			this.needsFinalization = false;
-			this.log(`Recording too short (${Date.now() - this.startTime}ms), discarding events`);
-		}
-		this.flush(true, true, "stop");
+		this.requestTerminalFlush("stop");
 		this.log("Recording stopped");
 	}
 	onSessionRotated(prev, next) {
@@ -415,7 +424,7 @@ var ReplayTracker = class {
 				...event,
 				data: {
 					...data,
-					href: sanitizeUrl(data.href, this.options.trackHash ?? false)
+					href: this.sanitize(data.href)
 				}
 			};
 		}
@@ -446,7 +455,8 @@ var ReplayTracker = class {
 		if (!this.hasReachedMinLength()) {
 			this.dropEvents();
 			this.needsFinalization = false;
-			return;
+			this.log(`Recording too short (${Date.now() - this.startTime}ms), discarding events`);
+			if (this.pending.length === 0) return;
 		}
 		this.flush(true, true, reason);
 	}
@@ -536,14 +546,19 @@ var ReplayTracker = class {
 			sequence,
 			sequenceContractVersion: 1,
 			timestamp: now,
-			url: this.viewUrl || sanitizeUrl(window.location.href, this.options.trackHash ?? false),
+			url: this.viewUrl || this.sanitize(window.location.href),
 			...isFinal ? { isFinal: true } : {},
 			flushReason,
 			events
 		};
 	}
 	eventSizeBytes(event) {
-		return textEncoder.encode(JSON.stringify(event)).byteLength + 1;
+		let size = eventSizeCache.get(event);
+		if (size === void 0) {
+			size = textEncoder.encode(JSON.stringify(event)).byteLength + 1;
+			eventSizeCache.set(event, size);
+		}
+		return size;
 	}
 	batchSizeBytes(batch) {
 		const cached = batchSizeCache.get(batch);
@@ -577,7 +592,7 @@ var ReplayTracker = class {
 		}
 		const rotation = touchActivity(this.options.siteKey, this.lastCookielessMode);
 		if (rotation) this.applySessionRotation(rotation.prev, rotation.next);
-		const context = getSessionContext(this.options.siteKey, this.lastCookielessMode);
+		const context = this.sessionContext();
 		this.enqueueEventsIfReady(context, flushReason, lowLatency ? this.maxLowLatencyBatchSizeBytes : this.maxBatchSizeBytes);
 		if (!isFinal) return this.sendPending(lowLatency);
 		this.finalizeSession(context, flushReason);
@@ -629,33 +644,25 @@ var ReplayTracker = class {
 	}
 	async sendBatch(batch, lowLatency) {
 		const json = JSON.stringify(batch);
-		const lowLatencySafe = lowLatency && this.batchSizeBytes(batch) <= DEFAULT_MAX_LOW_LATENCY_BATCH_SIZE_BYTES;
-		const sendOptions = {
+		const keepalive = lowLatency && this.batchSizeBytes(batch) <= KEEPALIVE_LIMIT_BYTES;
+		const send = (data, contentType, query = "") => sendData({
+			url: `${this.endpoint}${query}`,
+			data,
+			contentType,
 			debug: this.options.debug,
 			debugPrefix: "[Replay]",
-			useBeacon: lowLatencySafe,
-			keepalive: lowLatencySafe,
+			useBeacon: keepalive,
+			keepalive,
 			settleRejected: true
-		};
-		if (!lowLatency && (this.options.compress ?? true) && this.compressionSupported) try {
-			const stream = new Blob([json]).stream().pipeThrough(new CompressionStream("gzip"));
-			const compressed = new Uint8Array(await new Response(stream).arrayBuffer());
+		});
+		if (!lowLatency && this.compress) try {
+			const compressed = await gzip(json);
 			this.log(`Compressed ${json.length}B -> ${compressed.byteLength}B (${Math.round(compressed.byteLength / json.length * 100)}%)`);
-			return sendData({
-				url: `${this.endpoint}?encoding=gzip`,
-				data: compressed,
-				contentType: "application/octet-stream",
-				...sendOptions
-			});
+			return send(compressed, "application/octet-stream", "?encoding=gzip");
 		} catch {
 			this.log("Compression failed, using uncompressed");
 		}
-		return sendData({
-			url: this.endpoint,
-			data: json,
-			contentType: "application/json",
-			...sendOptions
-		});
+		return send(json, "application/json");
 	}
 };
 //#endregion

package/dist/web-vitals.d.ts

@@ -1,4 +1,4 @@
-import { t as AnalyticsExtension } from "./chunks/extensions-DZDQn8O8.js";
+import { t as AnalyticsExtension } from "./chunks/extensions-BfubKIzk.js";
 //#region src/web-vitals.d.ts
 export interface WebVitalsOptions {
   siteKey: string;

package/dist/web-vitals.js

@@ -1,4 +1,5 @@
-import { f as resolveBaseUrl, p as sanitizeUrl, r as getSessionContext, t as sendData, u as URLS } from "./chunks/send-data-D520oab1.js";
+import { a as sanitizeUrl, i as resolveBaseUrl, n as URLS, t as sendData } from "./chunks/send-data-DYZZjeM-.js";
+import { n as getSessionContext } from "./chunks/session-manager-CFQEWbgo.js";
 import { onCLS, onFCP, onINP, onLCP, onTTFB } from "web-vitals/attribution";
 //#region src/utils/web-vitals-collector.ts
 const collectors = /* @__PURE__ */ new WeakMap();

package/package.json

@@ -23,6 +23,11 @@
 			"import": "./dist/error.js",
 			"default": "./dist/error.js"
 		},
+		"./flags": {
+			"types": "./dist/flags.d.ts",
+			"import": "./dist/flags.js",
+			"default": "./dist/flags.js"
+		},
 		"./web-vitals": {
 			"types": "./dist/web-vitals.d.ts",
 			"import": "./dist/web-vitals.js",
@@ -37,7 +42,7 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"version": "0.11.0",
+	"version": "0.12.0",
 	"scripts": {
 		"build": "tsdown && bun run check-size",
 		"dev": "bun run build",
@@ -46,15 +51,15 @@
 		"check-size": "node scripts/check-bundle-size.mjs"
 	},
 	"devDependencies": {
-		"@rrweb/types": "^2.1.6",
+		"@rrweb/types": "^2.1.7",
 		"@types/bun": "^1.4.2",
 		"tsdown": "^0.23.0",
 		"typescript": "^7.0.2"
 	},
 	"dependencies": {
-		"@rrweb/record": "^2.1.6",
-		"@rrweb/rrweb-plugin-console-record": "^2.1.6",
-		"@rrweb/rrweb-plugin-network-record": "^2.1.6",
-		"web-vitals": "^6.2.2"
+		"@rrweb/record": "^2.1.7",
+		"@rrweb/rrweb-plugin-console-record": "^2.1.7",
+		"@rrweb/rrweb-plugin-network-record": "^2.1.7",
+		"web-vitals": "^6.2.3"
 	}
 }