@kubesense/kubesense-browser-rum-core 1.8.0 → 2.0.0-beta.1

package/esm/domain/view/viewMetrics/interactionCountPolyfill.mjs

@@ -0,0 +1,45 @@
+import { monitor } from "@kubesense/kubesense-js-core/monitor";
+//#region src/domain/view/viewMetrics/interactionCountPolyfill.ts
+/**
+* performance.interactionCount polyfill
+*
+* The interactionCount is an integer which counts the total number of distinct user interactions,
+* for which there was a unique interactionId.
+*
+* The interactionCount polyfill is an estimate based on a convention specific to Chrome. Cf: https://github.com/GoogleChrome/web-vitals/pull/213
+* This is currently not an issue as the polyfill is only used for INP which is currently only supported on Chrome.
+* Hopefully when/if other browsers will support INP, they will also implement performance.interactionCount at the same time, so we won't need that polyfill.
+*
+* Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/main/src/lib/polyfills/interactionCountPolyfill.ts
+*/
+let observer;
+let interactionCountEstimate = 0;
+let minKnownInteractionId = Infinity;
+let maxKnownInteractionId = 0;
+function initInteractionCountPolyfill() {
+	if ("interactionCount" in performance || observer) return;
+	observer = new window.PerformanceObserver(monitor((entries) => {
+		entries.getEntries().forEach((e) => {
+			const entry = e;
+			if (entry.interactionId) {
+				minKnownInteractionId = Math.min(minKnownInteractionId, entry.interactionId);
+				maxKnownInteractionId = Math.max(maxKnownInteractionId, entry.interactionId);
+				interactionCountEstimate = (maxKnownInteractionId - minKnownInteractionId) / 7 + 1;
+			}
+		});
+	}));
+	observer.observe({
+		type: "event",
+		buffered: true,
+		durationThreshold: 0
+	});
+}
+/**
+* Returns the `interactionCount` value using the native API (if available)
+* or the polyfill estimate in this module.
+*/
+const getInteractionCount = () => observer ? interactionCountEstimate : window.performance.interactionCount || 0;
+//#endregion
+export { getInteractionCount, initInteractionCountPolyfill };
+
+//# sourceMappingURL=interactionCountPolyfill.mjs.map

package/esm/domain/view/viewMetrics/interactionCountPolyfill.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactionCountPolyfill.mjs","names":[],"sources":["../../../../src/domain/view/viewMetrics/interactionCountPolyfill.ts"],"sourcesContent":["/**\n * performance.interactionCount polyfill\n *\n * The interactionCount is an integer which counts the total number of distinct user interactions,\n * for which there was a unique interactionId.\n *\n * The interactionCount polyfill is an estimate based on a convention specific to Chrome. Cf: https://github.com/GoogleChrome/web-vitals/pull/213\n * This is currently not an issue as the polyfill is only used for INP which is currently only supported on Chrome.\n * Hopefully when/if other browsers will support INP, they will also implement performance.interactionCount at the same time, so we won't need that polyfill.\n *\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/main/src/lib/polyfills/interactionCountPolyfill.ts\n */\n\nimport { monitor } from '@kubesense/kubesense-js-core/monitor'\nimport type {\n  BrowserWindow,\n  RumPerformanceEventTiming,\n  RumPerformanceObserver,\n} from '../../../browser/performanceObservable'\n\nlet observer: RumPerformanceObserver | undefined\n\nlet interactionCountEstimate = 0\nlet minKnownInteractionId = Infinity\nlet maxKnownInteractionId = 0\n\nexport function initInteractionCountPolyfill() {\n  if ('interactionCount' in performance || observer) {\n    return\n  }\n\n  observer = new (window as BrowserWindow).PerformanceObserver(\n    monitor((entries: PerformanceObserverEntryList) => {\n      entries.getEntries().forEach((e) => {\n        const entry = e as unknown as RumPerformanceEventTiming\n\n        if (entry.interactionId) {\n          minKnownInteractionId = Math.min(minKnownInteractionId, entry.interactionId)\n          maxKnownInteractionId = Math.max(maxKnownInteractionId, entry.interactionId)\n\n          interactionCountEstimate = (maxKnownInteractionId - minKnownInteractionId) / 7 + 1\n        }\n      })\n    })\n  )\n\n  observer.observe({ type: 'event', buffered: true, durationThreshold: 0 })\n}\n\n/**\n * Returns the `interactionCount` value using the native API (if available)\n * or the polyfill estimate in this module.\n */\nexport const getInteractionCount = () =>\n  observer ? interactionCountEstimate : (window as BrowserWindow).performance.interactionCount || 0\n\nexport function resetInteractionCountPolyfill() {\n  if (observer) {\n    observer.disconnect()\n\n    observer = undefined\n    interactionCountEstimate = 0\n    minKnownInteractionId = Infinity\n    maxKnownInteractionId = 0\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAoBA,IAAI;AAEJ,IAAI,2BAA2B;AAC/B,IAAI,wBAAwB;AAC5B,IAAI,wBAAwB;AAE5B,SAAgB,+BAA+B;CAC7C,IAAI,sBAAsB,eAAe,UACvC;CAGF,WAAW,IAAK,OAAyB,oBACvC,SAAS,YAA0C;EACjD,QAAQ,WAAW,CAAC,CAAC,SAAS,MAAM;GAClC,MAAM,QAAQ;GAEd,IAAI,MAAM,eAAe;IACvB,wBAAwB,KAAK,IAAI,uBAAuB,MAAM,aAAa;IAC3E,wBAAwB,KAAK,IAAI,uBAAuB,MAAM,aAAa;IAE3E,4BAA4B,wBAAwB,yBAAyB,IAAI;GACnF;EACF,CAAC;CACH,CAAC,CACH;CAEA,SAAS,QAAQ;EAAE,MAAM;EAAS,UAAU;EAAM,mBAAmB;CAAE,CAAC;AAC1E;;;;;AAMA,MAAa,4BACX,WAAW,2BAA4B,OAAyB,YAAY,oBAAoB"}

package/esm/domain/view/viewMetrics/trackBfcacheMetrics.mjs

@@ -0,0 +1,18 @@
+import { trackRestoredFirstContentfulPaint } from "./trackFirstContentfulPaint.mjs";
+//#region src/domain/view/viewMetrics/trackBfcacheMetrics.ts
+/**
+* BFCache keeps a full in-memory snapshot of the DOM. When the page is restored, nothing needs to be fetched, so the whole
+* viewport repaints in a single frame. Consequently, LCP almost always equals FCP.
+* (See: https://github.com/GoogleChrome/web-vitals/pull/87)
+*/
+function trackBfcacheMetrics(viewStart, metrics, scheduleViewUpdate) {
+	trackRestoredFirstContentfulPaint(viewStart.relative, (paintTime) => {
+		metrics.firstContentfulPaint = paintTime;
+		metrics.largestContentfulPaint = { value: paintTime };
+		scheduleViewUpdate();
+	});
+}
+//#endregion
+export { trackBfcacheMetrics };
+
+//# sourceMappingURL=trackBfcacheMetrics.mjs.map

package/esm/domain/view/viewMetrics/trackBfcacheMetrics.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackBfcacheMetrics.mjs","names":[],"sources":["../../../../src/domain/view/viewMetrics/trackBfcacheMetrics.ts"],"sourcesContent":["import type { RelativeTime, ClocksState } from '@kubesense/kubesense-js-core/time'\nimport type { InitialViewMetrics } from './trackInitialViewMetrics'\nimport { trackRestoredFirstContentfulPaint } from './trackFirstContentfulPaint'\n\n/**\n * BFCache keeps a full in-memory snapshot of the DOM. When the page is restored, nothing needs to be fetched, so the whole\n * viewport repaints in a single frame. Consequently, LCP almost always equals FCP.\n * (See: https://github.com/GoogleChrome/web-vitals/pull/87)\n */\nexport function trackBfcacheMetrics(\n  viewStart: ClocksState,\n  metrics: InitialViewMetrics,\n  scheduleViewUpdate: () => void\n) {\n  trackRestoredFirstContentfulPaint(viewStart.relative, (paintTime) => {\n    metrics.firstContentfulPaint = paintTime\n    metrics.largestContentfulPaint = { value: paintTime as RelativeTime }\n    scheduleViewUpdate()\n  })\n}\n"],"mappings":";;;;;;;AASA,SAAgB,oBACd,WACA,SACA,oBACA;CACA,kCAAkC,UAAU,WAAW,cAAc;EACnE,QAAQ,uBAAuB;EAC/B,QAAQ,yBAAyB,EAAE,OAAO,UAA0B;EACpE,mBAAmB;CACrB,CAAC;AACH"}

package/esm/domain/view/viewMetrics/trackCommonViewMetrics.mjs

@@ -0,0 +1,54 @@
+import { trackCumulativeLayoutShift } from "./trackCumulativeLayoutShift.mjs";
+import { trackInteractionToNextPaint } from "./trackInteractionToNextPaint.mjs";
+import { trackLoadingTime } from "./trackLoadingTime.mjs";
+import { trackScrollMetrics } from "./trackScrollMetrics.mjs";
+import { elapsed, timeStampNow } from "@kubesense/kubesense-js-core/time";
+//#region src/domain/view/viewMetrics/trackCommonViewMetrics.ts
+function trackCommonViewMetrics(lifeCycle, domMutationObservable, windowOpenObservable, configuration, scheduleViewUpdate, loadingType, viewStart) {
+	const commonViewMetrics = {};
+	let hasManualLoadingTime = false;
+	let viewEnded = false;
+	const { stop: stopLoadingTimeTracking, setLoadEvent } = trackLoadingTime(lifeCycle, domMutationObservable, windowOpenObservable, configuration, loadingType, viewStart, (newLoadingTime) => {
+		if (!hasManualLoadingTime) {
+			commonViewMetrics.loadingTime = newLoadingTime;
+			scheduleViewUpdate();
+		}
+	});
+	const { stop: stopScrollMetricsTracking } = trackScrollMetrics(viewStart, (newScrollMetrics) => {
+		commonViewMetrics.scroll = newScrollMetrics;
+	});
+	const { stop: stopCLSTracking } = trackCumulativeLayoutShift(configuration, viewStart.relative, (cumulativeLayoutShift) => {
+		commonViewMetrics.cumulativeLayoutShift = cumulativeLayoutShift;
+		scheduleViewUpdate();
+	});
+	const { stop: stopINPTracking, getInteractionToNextPaint, setViewEnd: setINPViewEnd } = trackInteractionToNextPaint(configuration, viewStart.relative, loadingType);
+	return {
+		stop: () => {
+			stopLoadingTimeTracking();
+			stopCLSTracking();
+			stopScrollMetricsTracking();
+		},
+		stopINPTracking,
+		setLoadEvent,
+		setViewEnd: (viewEndTime) => {
+			viewEnded = true;
+			setINPViewEnd(viewEndTime);
+		},
+		getCommonViewMetrics: () => {
+			commonViewMetrics.interactionToNextPaint = getInteractionToNextPaint();
+			return commonViewMetrics;
+		},
+		setLoadingTime: (callTimestamp) => {
+			if (viewEnded) return;
+			const loadingTime = elapsed(viewStart.timeStamp, callTimestamp ?? timeStampNow());
+			if (!hasManualLoadingTime) stopLoadingTimeTracking();
+			hasManualLoadingTime = true;
+			commonViewMetrics.loadingTime = loadingTime;
+			scheduleViewUpdate();
+		}
+	};
+}
+//#endregion
+export { trackCommonViewMetrics };
+
+//# sourceMappingURL=trackCommonViewMetrics.mjs.map

package/esm/domain/view/viewMetrics/trackCommonViewMetrics.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackCommonViewMetrics.mjs","names":[],"sources":["../../../../src/domain/view/viewMetrics/trackCommonViewMetrics.ts"],"sourcesContent":["import type { ClocksState, RelativeTime, Duration, TimeStamp } from '@kubesense/kubesense-js-core/time'\nimport type { Observable } from '@kubesense/kubesense-browser-core'\nimport { elapsed, timeStampNow } from '@kubesense/kubesense-js-core/time'\nimport type { ViewLoadingType } from '../../../rawRumEvent.types'\nimport type { RumConfiguration } from '../../configuration'\nimport type { LifeCycle } from '../../lifeCycle'\nimport type { RumMutationRecord } from '../../../browser/domMutationObservable'\nimport type { CumulativeLayoutShift } from './trackCumulativeLayoutShift'\nimport { trackCumulativeLayoutShift } from './trackCumulativeLayoutShift'\nimport type { InteractionToNextPaint } from './trackInteractionToNextPaint'\nimport { trackInteractionToNextPaint } from './trackInteractionToNextPaint'\nimport { trackLoadingTime } from './trackLoadingTime'\nimport type { ScrollMetrics } from './trackScrollMetrics'\nimport { trackScrollMetrics } from './trackScrollMetrics'\n\nexport interface CommonViewMetrics {\n  loadingTime?: Duration\n  cumulativeLayoutShift?: CumulativeLayoutShift\n  interactionToNextPaint?: InteractionToNextPaint\n  scroll?: ScrollMetrics\n}\n\nexport function trackCommonViewMetrics(\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<RumMutationRecord[]>,\n  windowOpenObservable: Observable<void>,\n  configuration: RumConfiguration,\n  scheduleViewUpdate: () => void,\n  loadingType: ViewLoadingType,\n  viewStart: ClocksState\n) {\n  const commonViewMetrics: CommonViewMetrics = {}\n  let hasManualLoadingTime = false\n  let viewEnded = false\n\n  const { stop: stopLoadingTimeTracking, setLoadEvent } = trackLoadingTime(\n    lifeCycle,\n    domMutationObservable,\n    windowOpenObservable,\n    configuration,\n    loadingType,\n    viewStart,\n    (newLoadingTime) => {\n      if (!hasManualLoadingTime) {\n        commonViewMetrics.loadingTime = newLoadingTime\n        scheduleViewUpdate()\n      }\n    }\n  )\n\n  const { stop: stopScrollMetricsTracking } = trackScrollMetrics(viewStart, (newScrollMetrics) => {\n    commonViewMetrics.scroll = newScrollMetrics\n  })\n\n  const { stop: stopCLSTracking } = trackCumulativeLayoutShift(\n    configuration,\n    viewStart.relative,\n    (cumulativeLayoutShift) => {\n      commonViewMetrics.cumulativeLayoutShift = cumulativeLayoutShift\n      scheduleViewUpdate()\n    }\n  )\n\n  const {\n    stop: stopINPTracking,\n    getInteractionToNextPaint,\n    setViewEnd: setINPViewEnd,\n  } = trackInteractionToNextPaint(configuration, viewStart.relative, loadingType)\n\n  return {\n    stop: () => {\n      stopLoadingTimeTracking()\n      stopCLSTracking()\n      stopScrollMetricsTracking()\n    },\n    stopINPTracking,\n    setLoadEvent,\n    setViewEnd: (viewEndTime: RelativeTime) => {\n      viewEnded = true\n      setINPViewEnd(viewEndTime)\n    },\n    getCommonViewMetrics: () => {\n      commonViewMetrics.interactionToNextPaint = getInteractionToNextPaint()\n      return commonViewMetrics\n    },\n    setLoadingTime: (callTimestamp?: TimeStamp) => {\n      if (viewEnded) {\n        return\n      }\n      const loadingTime = elapsed(viewStart.timeStamp, callTimestamp ?? timeStampNow())\n      if (!hasManualLoadingTime) {\n        stopLoadingTimeTracking()\n      }\n      hasManualLoadingTime = true\n      commonViewMetrics.loadingTime = loadingTime\n      scheduleViewUpdate()\n    },\n  }\n}\n"],"mappings":";;;;;;AAsBA,SAAgB,uBACd,WACA,uBACA,sBACA,eACA,oBACA,aACA,WACA;CACA,MAAM,oBAAuC,CAAC;CAC9C,IAAI,uBAAuB;CAC3B,IAAI,YAAY;CAEhB,MAAM,EAAE,MAAM,yBAAyB,iBAAiB,iBACtD,WACA,uBACA,sBACA,eACA,aACA,YACC,mBAAmB;EAClB,IAAI,CAAC,sBAAsB;GACzB,kBAAkB,cAAc;GAChC,mBAAmB;EACrB;CACF,CACF;CAEA,MAAM,EAAE,MAAM,8BAA8B,mBAAmB,YAAY,qBAAqB;EAC9F,kBAAkB,SAAS;CAC7B,CAAC;CAED,MAAM,EAAE,MAAM,oBAAoB,2BAChC,eACA,UAAU,WACT,0BAA0B;EACzB,kBAAkB,wBAAwB;EAC1C,mBAAmB;CACrB,CACF;CAEA,MAAM,EACJ,MAAM,iBACN,2BACA,YAAY,kBACV,4BAA4B,eAAe,UAAU,UAAU,WAAW;CAE9E,OAAO;EACL,YAAY;GACV,wBAAwB;GACxB,gBAAgB;GAChB,0BAA0B;EAC5B;EACA;EACA;EACA,aAAa,gBAA8B;GACzC,YAAY;GACZ,cAAc,WAAW;EAC3B;EACA,4BAA4B;GAC1B,kBAAkB,yBAAyB,0BAA0B;GACrE,OAAO;EACT;EACA,iBAAiB,kBAA8B;GAC7C,IAAI,WACF;GAEF,MAAM,cAAc,QAAQ,UAAU,WAAW,iBAAiB,aAAa,CAAC;GAChF,IAAI,CAAC,sBACH,wBAAwB;GAE1B,uBAAuB;GACvB,kBAAkB,cAAc;GAChC,mBAAmB;EACrB;CACF;AACF"}

package/esm/domain/view/viewMetrics/trackCumulativeLayoutShift.mjs

@@ -0,0 +1,117 @@
+import { isElementNode } from "../../../browser/htmlDomUtils.mjs";
+import { createPerformanceObservable, supportPerformanceTimingEvent } from "../../../browser/performanceObservable.mjs";
+import { getSelectorFromElement } from "../../getSelectorFromElement.mjs";
+import { getClsAttributionImpactedArea } from "./getClsAttributionImpactedArea.mjs";
+import { ONE_SECOND, elapsed } from "@kubesense/kubesense-js-core/time";
+import { noop, round } from "@kubesense/kubesense-browser-core";
+//#region src/domain/view/viewMetrics/trackCumulativeLayoutShift.ts
+/**
+* Track the cumulative layout shifts (CLS).
+* Layout shifts are grouped into session windows.
+* The minimum gap between session windows is 1 second.
+* The maximum duration of a session window is 5 second.
+* The session window layout shift value is the sum of layout shifts inside it.
+* The CLS value is the max of session windows values.
+*
+* This yields a new value whenever the CLS value is updated (a higher session window value is computed).
+*
+* See isLayoutShiftSupported to check for browser support.
+*
+* Documentation:
+* https://web.dev/cls/
+* https://web.dev/evolving-cls/
+* Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getCLS.ts
+*/
+function trackCumulativeLayoutShift(configuration, viewStart, callback) {
+	if (!isLayoutShiftSupported()) return { stop: noop };
+	let maxClsValue = 0;
+	let biggestShift;
+	callback({ value: 0 });
+	const slidingWindow = slidingSessionWindow();
+	const performanceSubscription = createPerformanceObservable({
+		type: "layout-shift",
+		buffered: true
+	}).subscribe((entries) => {
+		for (const entry of entries) {
+			if (entry.hadRecentInput || entry.startTime < viewStart) continue;
+			const { cumulatedValue, isMaxValue } = slidingWindow.update(entry);
+			if (isMaxValue) {
+				const attribution = getTopImpactedElement(entry.sources);
+				biggestShift = {
+					target: attribution?.node ? new WeakRef(attribution.node) : void 0,
+					time: elapsed(viewStart, entry.startTime),
+					previousRect: attribution?.previousRect,
+					currentRect: attribution?.currentRect,
+					devicePixelRatio: window.devicePixelRatio
+				};
+			}
+			if (cumulatedValue > maxClsValue) {
+				maxClsValue = cumulatedValue;
+				const target = biggestShift?.target?.deref();
+				callback({
+					value: round(maxClsValue, 4),
+					targetSelector: target && getSelectorFromElement(target, configuration.actionNameAttribute),
+					time: biggestShift?.time,
+					previousRect: biggestShift?.previousRect ? asRumRect(biggestShift.previousRect) : void 0,
+					currentRect: biggestShift?.currentRect ? asRumRect(biggestShift.currentRect) : void 0,
+					devicePixelRatio: biggestShift?.devicePixelRatio
+				});
+			}
+		}
+	});
+	return { stop: () => {
+		performanceSubscription.unsubscribe();
+	} };
+}
+function getTopImpactedElement(sources) {
+	let topImpactedSource;
+	for (const source of sources) if (source.node && isElementNode(source.node)) {
+		const currentImpactedArea = getClsAttributionImpactedArea(source);
+		if (!topImpactedSource || getClsAttributionImpactedArea(topImpactedSource) < currentImpactedArea) topImpactedSource = source;
+	}
+	return topImpactedSource;
+}
+function asRumRect({ x, y, width, height }) {
+	return {
+		x,
+		y,
+		width,
+		height
+	};
+}
+const MAX_WINDOW_DURATION = 5 * ONE_SECOND;
+const MAX_UPDATE_GAP = ONE_SECOND;
+function slidingSessionWindow() {
+	let cumulatedValue = 0;
+	let startTime;
+	let endTime;
+	let maxValue = 0;
+	return { update: (entry) => {
+		const shouldCreateNewWindow = startTime === void 0 || entry.startTime - endTime >= MAX_UPDATE_GAP || entry.startTime - startTime >= MAX_WINDOW_DURATION;
+		let isMaxValue;
+		if (shouldCreateNewWindow) {
+			startTime = endTime = entry.startTime;
+			maxValue = cumulatedValue = entry.value;
+			isMaxValue = true;
+		} else {
+			cumulatedValue += entry.value;
+			endTime = entry.startTime;
+			isMaxValue = entry.value > maxValue;
+			if (isMaxValue) maxValue = entry.value;
+		}
+		return {
+			cumulatedValue,
+			isMaxValue
+		};
+	} };
+}
+/**
+* Check whether `layout-shift` is supported by the browser.
+*/
+function isLayoutShiftSupported() {
+	return supportPerformanceTimingEvent("layout-shift") && "WeakRef" in window;
+}
+//#endregion
+export { MAX_WINDOW_DURATION, isLayoutShiftSupported, trackCumulativeLayoutShift };
+
+//# sourceMappingURL=trackCumulativeLayoutShift.mjs.map

package/esm/domain/view/viewMetrics/trackCumulativeLayoutShift.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackCumulativeLayoutShift.mjs","names":[],"sources":["../../../../src/domain/view/viewMetrics/trackCumulativeLayoutShift.ts"],"sourcesContent":["import { round, noop } from '@kubesense/kubesense-browser-core'\nimport { ONE_SECOND, elapsed } from '@kubesense/kubesense-js-core/time'\nimport type { Duration, RelativeTime } from '@kubesense/kubesense-js-core/time'\nimport type { WeakRef, WeakRefConstructor } from '@kubesense/kubesense-browser-core'\nimport { isElementNode } from '../../../browser/htmlDomUtils'\nimport type { RumLayoutShiftAttribution, RumLayoutShiftTiming } from '../../../browser/performanceObservable'\nimport {\n  supportPerformanceTimingEvent,\n  RumPerformanceEntryType,\n  createPerformanceObservable,\n} from '../../../browser/performanceObservable'\nimport { getSelectorFromElement } from '../../getSelectorFromElement'\nimport type { RumConfiguration } from '../../configuration'\nimport type { RumRect } from '../../../rumEvent.types'\nimport { getClsAttributionImpactedArea } from './getClsAttributionImpactedArea'\n\ndeclare const WeakRef: WeakRefConstructor\n\nexport interface CumulativeLayoutShift {\n  value: number\n  targetSelector?: string\n  time?: Duration\n  previousRect?: RumRect\n  currentRect?: RumRect\n  devicePixelRatio?: number\n}\n\ninterface LayoutShiftInstance {\n  target: WeakRef<Element> | undefined\n  time: Duration\n  previousRect: DOMRectReadOnly | undefined\n  currentRect: DOMRectReadOnly | undefined\n  devicePixelRatio: number\n}\n\n/**\n * Track the cumulative layout shifts (CLS).\n * Layout shifts are grouped into session windows.\n * The minimum gap between session windows is 1 second.\n * The maximum duration of a session window is 5 second.\n * The session window layout shift value is the sum of layout shifts inside it.\n * The CLS value is the max of session windows values.\n *\n * This yields a new value whenever the CLS value is updated (a higher session window value is computed).\n *\n * See isLayoutShiftSupported to check for browser support.\n *\n * Documentation:\n * https://web.dev/cls/\n * https://web.dev/evolving-cls/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getCLS.ts\n */\nexport function trackCumulativeLayoutShift(\n  configuration: RumConfiguration,\n  viewStart: RelativeTime,\n  callback: (cumulativeLayoutShift: CumulativeLayoutShift) => void\n) {\n  if (!isLayoutShiftSupported()) {\n    return {\n      stop: noop,\n    }\n  }\n\n  let maxClsValue = 0\n  let biggestShift: LayoutShiftInstance | undefined\n\n  // if no layout shift happen the value should be reported as 0\n  callback({\n    value: 0,\n  })\n\n  const slidingWindow = slidingSessionWindow()\n  const performanceSubscription = createPerformanceObservable({\n    type: RumPerformanceEntryType.LAYOUT_SHIFT,\n    buffered: true,\n  }).subscribe((entries) => {\n    for (const entry of entries) {\n      if (entry.hadRecentInput || entry.startTime < viewStart) {\n        continue\n      }\n\n      const { cumulatedValue, isMaxValue } = slidingWindow.update(entry)\n\n      if (isMaxValue) {\n        const attribution = getTopImpactedElement(entry.sources)\n        biggestShift = {\n          target: attribution?.node ? new WeakRef(attribution.node) : undefined,\n          time: elapsed(viewStart, entry.startTime),\n          previousRect: attribution?.previousRect,\n          currentRect: attribution?.currentRect,\n          devicePixelRatio: window.devicePixelRatio,\n        }\n      }\n\n      if (cumulatedValue > maxClsValue) {\n        maxClsValue = cumulatedValue\n        const target = biggestShift?.target?.deref()\n\n        callback({\n          value: round(maxClsValue, 4),\n          targetSelector: target && getSelectorFromElement(target, configuration.actionNameAttribute),\n          time: biggestShift?.time,\n          previousRect: biggestShift?.previousRect ? asRumRect(biggestShift.previousRect) : undefined,\n          currentRect: biggestShift?.currentRect ? asRumRect(biggestShift.currentRect) : undefined,\n          devicePixelRatio: biggestShift?.devicePixelRatio,\n        })\n      }\n    }\n  })\n\n  return {\n    stop: () => {\n      performanceSubscription.unsubscribe()\n    },\n  }\n}\n\nfunction getTopImpactedElement(\n  sources: RumLayoutShiftAttribution[]\n): (RumLayoutShiftAttribution & { node: Element }) | undefined {\n  let topImpactedSource: (RumLayoutShiftAttribution & { node: Element }) | undefined\n  for (const source of sources) {\n    if (source.node && isElementNode(source.node)) {\n      const currentImpactedArea = getClsAttributionImpactedArea(source)\n      if (!topImpactedSource || getClsAttributionImpactedArea(topImpactedSource) < currentImpactedArea) {\n        topImpactedSource = source as RumLayoutShiftAttribution & { node: Element }\n      }\n    }\n  }\n  return topImpactedSource\n}\n\nfunction asRumRect({ x, y, width, height }: DOMRectReadOnly): RumRect {\n  return { x, y, width, height }\n}\n\nexport const MAX_WINDOW_DURATION = 5 * ONE_SECOND\nconst MAX_UPDATE_GAP = ONE_SECOND\n\nfunction slidingSessionWindow() {\n  let cumulatedValue = 0\n  let startTime: RelativeTime\n  let endTime: RelativeTime\n  let maxValue = 0\n\n  return {\n    update: (entry: RumLayoutShiftTiming) => {\n      const shouldCreateNewWindow =\n        startTime === undefined ||\n        entry.startTime - endTime >= MAX_UPDATE_GAP ||\n        entry.startTime - startTime >= MAX_WINDOW_DURATION\n\n      let isMaxValue: boolean\n\n      if (shouldCreateNewWindow) {\n        startTime = endTime = entry.startTime\n        maxValue = cumulatedValue = entry.value\n        isMaxValue = true\n      } else {\n        cumulatedValue += entry.value\n        endTime = entry.startTime\n        isMaxValue = entry.value > maxValue\n\n        if (isMaxValue) {\n          maxValue = entry.value\n        }\n      }\n\n      return {\n        cumulatedValue,\n        isMaxValue,\n      }\n    },\n  }\n}\n\n/**\n * Check whether `layout-shift` is supported by the browser.\n */\nexport function isLayoutShiftSupported() {\n  return supportPerformanceTimingEvent(RumPerformanceEntryType.LAYOUT_SHIFT) && 'WeakRef' in window\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAoDA,SAAgB,2BACd,eACA,WACA,UACA;CACA,IAAI,CAAC,uBAAuB,GAC1B,OAAO,EACL,MAAM,KACR;CAGF,IAAI,cAAc;CAClB,IAAI;CAGJ,SAAS,EACP,OAAO,EACT,CAAC;CAED,MAAM,gBAAgB,qBAAqB;CAC3C,MAAM,0BAA0B,4BAA4B;EAC1D,MAAA;EACA,UAAU;CACZ,CAAC,CAAC,CAAC,WAAW,YAAY;EACxB,KAAK,MAAM,SAAS,SAAS;GAC3B,IAAI,MAAM,kBAAkB,MAAM,YAAY,WAC5C;GAGF,MAAM,EAAE,gBAAgB,eAAe,cAAc,OAAO,KAAK;GAEjE,IAAI,YAAY;IACd,MAAM,cAAc,sBAAsB,MAAM,OAAO;IACvD,eAAe;KACb,QAAQ,aAAa,OAAO,IAAI,QAAQ,YAAY,IAAI,IAAI,KAAA;KAC5D,MAAM,QAAQ,WAAW,MAAM,SAAS;KACxC,cAAc,aAAa;KAC3B,aAAa,aAAa;KAC1B,kBAAkB,OAAO;IAC3B;GACF;GAEA,IAAI,iBAAiB,aAAa;IAChC,cAAc;IACd,MAAM,SAAS,cAAc,QAAQ,MAAM;IAE3C,SAAS;KACP,OAAO,MAAM,aAAa,CAAC;KAC3B,gBAAgB,UAAU,uBAAuB,QAAQ,cAAc,mBAAmB;KAC1F,MAAM,cAAc;KACpB,cAAc,cAAc,eAAe,UAAU,aAAa,YAAY,IAAI,KAAA;KAClF,aAAa,cAAc,cAAc,UAAU,aAAa,WAAW,IAAI,KAAA;KAC/E,kBAAkB,cAAc;IAClC,CAAC;GACH;EACF;CACF,CAAC;CAED,OAAO,EACL,YAAY;EACV,wBAAwB,YAAY;CACtC,EACF;AACF;AAEA,SAAS,sBACP,SAC6D;CAC7D,IAAI;CACJ,KAAK,MAAM,UAAU,SACnB,IAAI,OAAO,QAAQ,cAAc,OAAO,IAAI,GAAG;EAC7C,MAAM,sBAAsB,8BAA8B,MAAM;EAChE,IAAI,CAAC,qBAAqB,8BAA8B,iBAAiB,IAAI,qBAC3E,oBAAoB;CAExB;CAEF,OAAO;AACT;AAEA,SAAS,UAAU,EAAE,GAAG,GAAG,OAAO,UAAoC;CACpE,OAAO;EAAE;EAAG;EAAG;EAAO;CAAO;AAC/B;AAEA,MAAa,sBAAsB,IAAI;AACvC,MAAM,iBAAiB;AAEvB,SAAS,uBAAuB;CAC9B,IAAI,iBAAiB;CACrB,IAAI;CACJ,IAAI;CACJ,IAAI,WAAW;CAEf,OAAO,EACL,SAAS,UAAgC;EACvC,MAAM,wBACJ,cAAc,KAAA,KACd,MAAM,YAAY,WAAW,kBAC7B,MAAM,YAAY,aAAa;EAEjC,IAAI;EAEJ,IAAI,uBAAuB;GACzB,YAAY,UAAU,MAAM;GAC5B,WAAW,iBAAiB,MAAM;GAClC,aAAa;EACf,OAAO;GACL,kBAAkB,MAAM;GACxB,UAAU,MAAM;GAChB,aAAa,MAAM,QAAQ;GAE3B,IAAI,YACF,WAAW,MAAM;EAErB;EAEA,OAAO;GACL;GACA;EACF;CACF,EACF;AACF;;;;AAKA,SAAgB,yBAAyB;CACvC,OAAO,8BAAA,cAAkE,KAAK,aAAa;AAC7F"}

package/esm/domain/view/viewMetrics/trackFirstContentfulPaint.mjs

@@ -0,0 +1,29 @@
+import { createPerformanceObservable } from "../../../browser/performanceObservable.mjs";
+import { ONE_MINUTE, elapsed, relativeNow } from "@kubesense/kubesense-js-core/time";
+//#region src/domain/view/viewMetrics/trackFirstContentfulPaint.ts
+const FCP_MAXIMUM_DELAY = 10 * ONE_MINUTE;
+function trackFirstContentfulPaint(firstHidden, callback) {
+	return { stop: createPerformanceObservable({
+		type: "paint",
+		buffered: true
+	}).subscribe((entries) => {
+		const fcpEntry = entries.find((entry) => entry.name === "first-contentful-paint" && entry.startTime < firstHidden.timeStamp && entry.startTime < FCP_MAXIMUM_DELAY);
+		if (fcpEntry) callback(fcpEntry.startTime);
+	}).unsubscribe };
+}
+/**
+* Measure the First Contentful Paint after a BFCache restoration.
+* The DOM is restored synchronously, so we approximate the FCP with the first frame
+* rendered just after the pageshow event, using two nested requestAnimationFrame calls.
+*/
+function trackRestoredFirstContentfulPaint(viewStartRelative, callback) {
+	requestAnimationFrame(() => {
+		requestAnimationFrame(() => {
+			callback(elapsed(viewStartRelative, relativeNow()));
+		});
+	});
+}
+//#endregion
+export { FCP_MAXIMUM_DELAY, trackFirstContentfulPaint, trackRestoredFirstContentfulPaint };
+
+//# sourceMappingURL=trackFirstContentfulPaint.mjs.map

package/esm/domain/view/viewMetrics/trackFirstContentfulPaint.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackFirstContentfulPaint.mjs","names":[],"sources":["../../../../src/domain/view/viewMetrics/trackFirstContentfulPaint.ts"],"sourcesContent":["import type { RelativeTime, Duration } from '@kubesense/kubesense-js-core/time'\nimport { ONE_MINUTE, elapsed, relativeNow } from '@kubesense/kubesense-js-core/time'\nimport type { RumPerformancePaintTiming } from '../../../browser/performanceObservable'\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../../../browser/performanceObservable'\nimport type { FirstHidden } from './trackFirstHidden'\n\n// Discard FCP timings above a certain delay to avoid incorrect data\n// It happens in some cases like sleep mode or some browser implementations\nexport const FCP_MAXIMUM_DELAY = 10 * ONE_MINUTE\n\nexport function trackFirstContentfulPaint(firstHidden: FirstHidden, callback: (fcpTiming: RelativeTime) => void) {\n  const performanceSubscription = createPerformanceObservable({\n    type: RumPerformanceEntryType.PAINT,\n    buffered: true,\n  }).subscribe((entries) => {\n    const fcpEntry = entries.find(\n      (entry): entry is RumPerformancePaintTiming =>\n        entry.name === 'first-contentful-paint' &&\n        entry.startTime < firstHidden.timeStamp &&\n        entry.startTime < FCP_MAXIMUM_DELAY\n    )\n    if (fcpEntry) {\n      callback(fcpEntry.startTime)\n    }\n  })\n  return {\n    stop: performanceSubscription.unsubscribe,\n  }\n}\n\n/**\n * Measure the First Contentful Paint after a BFCache restoration.\n * The DOM is restored synchronously, so we approximate the FCP with the first frame\n * rendered just after the pageshow event, using two nested requestAnimationFrame calls.\n */\nexport function trackRestoredFirstContentfulPaint(viewStartRelative: RelativeTime, callback: (fcp: Duration) => void) {\n  requestAnimationFrame(() => {\n    requestAnimationFrame(() => {\n      callback(elapsed(viewStartRelative, relativeNow()))\n    })\n  })\n}\n"],"mappings":";;;AAQA,MAAa,oBAAoB,KAAK;AAEtC,SAAgB,0BAA0B,aAA0B,UAA6C;CAe/G,OAAO,EACL,MAf8B,4BAA4B;EAC1D,MAAA;EACA,UAAU;CACZ,CAAC,CAAC,CAAC,WAAW,YAAY;EACxB,MAAM,WAAW,QAAQ,MACtB,UACC,MAAM,SAAS,4BACf,MAAM,YAAY,YAAY,aAC9B,MAAM,YAAY,iBACtB;EACA,IAAI,UACF,SAAS,SAAS,SAAS;CAE/B,CAE8B,CAAC,CAAC,YAChC;AACF;;;;;;AAOA,SAAgB,kCAAkC,mBAAiC,UAAmC;CACpH,4BAA4B;EAC1B,4BAA4B;GAC1B,SAAS,QAAQ,mBAAmB,YAAY,CAAC,CAAC;EACpD,CAAC;CACH,CAAC;AACH"}

package/esm/domain/view/viewMetrics/trackFirstHidden.mjs

@@ -0,0 +1,33 @@
+import { supportPerformanceTimingEvent } from "../../../browser/performanceObservable.mjs";
+import { DOM_EVENT, addEventListeners, noop } from "@kubesense/kubesense-browser-core";
+//#region src/domain/view/viewMetrics/trackFirstHidden.ts
+function trackFirstHidden(viewStart, eventTarget = window) {
+	if (document.visibilityState === "hidden") return {
+		timeStamp: 0,
+		stop: noop
+	};
+	if (supportPerformanceTimingEvent("visibility-state")) {
+		const firstHiddenEntry = performance.getEntriesByType("visibility-state").filter((entry) => entry.name === "hidden").find((entry) => entry.startTime >= viewStart.relative);
+		if (firstHiddenEntry) return {
+			timeStamp: firstHiddenEntry.startTime,
+			stop: noop
+		};
+	}
+	let timeStamp = Infinity;
+	const { stop } = addEventListeners(eventTarget, [DOM_EVENT.PAGE_HIDE, DOM_EVENT.VISIBILITY_CHANGE], (event) => {
+		if (event.type === DOM_EVENT.PAGE_HIDE || document.visibilityState === "hidden") {
+			timeStamp = event.timeStamp;
+			stop();
+		}
+	}, { capture: true });
+	return {
+		get timeStamp() {
+			return timeStamp;
+		},
+		stop
+	};
+}
+//#endregion
+export { trackFirstHidden };
+
+//# sourceMappingURL=trackFirstHidden.mjs.map

package/esm/domain/view/viewMetrics/trackFirstHidden.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackFirstHidden.mjs","names":[],"sources":["../../../../src/domain/view/viewMetrics/trackFirstHidden.ts"],"sourcesContent":["import type { ClocksState, RelativeTime } from '@kubesense/kubesense-js-core/time'\nimport { addEventListeners, DOM_EVENT, noop } from '@kubesense/kubesense-browser-core'\nimport { supportPerformanceTimingEvent, RumPerformanceEntryType } from '../../../browser/performanceObservable'\n\nexport type FirstHidden = ReturnType<typeof trackFirstHidden>\n\nexport interface Options {\n  viewStart: ClocksState\n}\n\nexport function trackFirstHidden(viewStart: ClocksState, eventTarget: Window = window) {\n  if (document.visibilityState === 'hidden') {\n    return { timeStamp: 0 as RelativeTime, stop: noop }\n  }\n\n  if (supportPerformanceTimingEvent(RumPerformanceEntryType.VISIBILITY_STATE)) {\n    const firstHiddenEntry = performance\n      .getEntriesByType(RumPerformanceEntryType.VISIBILITY_STATE)\n      .filter((entry) => entry.name === 'hidden')\n      .find((entry) => entry.startTime >= viewStart.relative)\n\n    if (firstHiddenEntry) {\n      return { timeStamp: firstHiddenEntry.startTime as RelativeTime, stop: noop }\n    }\n  }\n\n  let timeStamp: RelativeTime = Infinity as RelativeTime\n\n  const { stop } = addEventListeners(\n    eventTarget,\n    [DOM_EVENT.PAGE_HIDE, DOM_EVENT.VISIBILITY_CHANGE],\n    (event) => {\n      if (event.type === DOM_EVENT.PAGE_HIDE || document.visibilityState === 'hidden') {\n        timeStamp = event.timeStamp as RelativeTime\n        stop()\n      }\n    },\n    { capture: true }\n  )\n\n  return {\n    get timeStamp() {\n      return timeStamp\n    },\n    stop,\n  }\n}\n"],"mappings":";;;AAUA,SAAgB,iBAAiB,WAAwB,cAAsB,QAAQ;CACrF,IAAI,SAAS,oBAAoB,UAC/B,OAAO;EAAE,WAAW;EAAmB,MAAM;CAAK;CAGpD,IAAI,8BAAA,kBAAsE,GAAG;EAC3E,MAAM,mBAAmB,YACtB,iBAAA,kBAAyD,CAAC,CAC1D,QAAQ,UAAU,MAAM,SAAS,QAAQ,CAAC,CAC1C,MAAM,UAAU,MAAM,aAAa,UAAU,QAAQ;EAExD,IAAI,kBACF,OAAO;GAAE,WAAW,iBAAiB;GAA2B,MAAM;EAAK;CAE/E;CAEA,IAAI,YAA0B;CAE9B,MAAM,EAAE,SAAS,kBACf,aACA,CAAC,UAAU,WAAW,UAAU,iBAAiB,IAChD,UAAU;EACT,IAAI,MAAM,SAAS,UAAU,aAAa,SAAS,oBAAoB,UAAU;GAC/E,YAAY,MAAM;GAClB,KAAK;EACP;CACF,GACA,EAAE,SAAS,KAAK,CAClB;CAEA,OAAO;EACL,IAAI,YAAY;GACd,OAAO;EACT;EACA;CACF;AACF"}

package/esm/domain/view/viewMetrics/trackInitialViewMetrics.mjs

@@ -0,0 +1,36 @@
+import { trackFirstContentfulPaint } from "./trackFirstContentfulPaint.mjs";
+import { trackNavigationTimings } from "./trackNavigationTimings.mjs";
+import { trackLargestContentfulPaint } from "./trackLargestContentfulPaint.mjs";
+import { trackFirstHidden } from "./trackFirstHidden.mjs";
+//#region src/domain/view/viewMetrics/trackInitialViewMetrics.ts
+function trackInitialViewMetrics(configuration, viewStart, setLoadEvent, scheduleViewUpdate) {
+	const initialViewMetrics = {};
+	const { stop: stopNavigationTracking } = trackNavigationTimings((navigationTimings) => {
+		setLoadEvent(navigationTimings.loadEvent);
+		initialViewMetrics.navigationTimings = navigationTimings;
+		scheduleViewUpdate();
+	});
+	const firstHidden = trackFirstHidden(viewStart);
+	const { stop: stopFCPTracking } = trackFirstContentfulPaint(firstHidden, (firstContentfulPaint) => {
+		initialViewMetrics.firstContentfulPaint = firstContentfulPaint;
+		scheduleViewUpdate();
+	});
+	const { stop: stopLCPTracking } = trackLargestContentfulPaint(configuration, firstHidden, window, (largestContentfulPaint) => {
+		initialViewMetrics.largestContentfulPaint = largestContentfulPaint;
+		scheduleViewUpdate();
+	});
+	function stop() {
+		stopNavigationTracking();
+		stopFCPTracking();
+		stopLCPTracking();
+		firstHidden.stop();
+	}
+	return {
+		stop,
+		initialViewMetrics
+	};
+}
+//#endregion
+export { trackInitialViewMetrics };
+
+//# sourceMappingURL=trackInitialViewMetrics.mjs.map

package/esm/domain/view/viewMetrics/trackInitialViewMetrics.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackInitialViewMetrics.mjs","names":[],"sources":["../../../../src/domain/view/viewMetrics/trackInitialViewMetrics.ts"],"sourcesContent":["import type { ClocksState, Duration } from '@kubesense/kubesense-js-core/time'\nimport type { RumConfiguration } from '../../configuration'\nimport { trackFirstContentfulPaint } from './trackFirstContentfulPaint'\nimport type { NavigationTimings } from './trackNavigationTimings'\nimport { trackNavigationTimings } from './trackNavigationTimings'\nimport type { LargestContentfulPaint } from './trackLargestContentfulPaint'\nimport { trackLargestContentfulPaint } from './trackLargestContentfulPaint'\nimport { trackFirstHidden } from './trackFirstHidden'\n\nexport interface InitialViewMetrics {\n  firstContentfulPaint?: Duration\n  navigationTimings?: NavigationTimings\n  largestContentfulPaint?: LargestContentfulPaint\n}\n\nexport function trackInitialViewMetrics(\n  configuration: RumConfiguration,\n  viewStart: ClocksState,\n  setLoadEvent: (loadEnd: Duration) => void,\n  scheduleViewUpdate: () => void\n) {\n  const initialViewMetrics: InitialViewMetrics = {}\n\n  const { stop: stopNavigationTracking } = trackNavigationTimings((navigationTimings) => {\n    setLoadEvent(navigationTimings.loadEvent)\n    initialViewMetrics.navigationTimings = navigationTimings\n    scheduleViewUpdate()\n  })\n\n  const firstHidden = trackFirstHidden(viewStart)\n  const { stop: stopFCPTracking } = trackFirstContentfulPaint(firstHidden, (firstContentfulPaint) => {\n    initialViewMetrics.firstContentfulPaint = firstContentfulPaint\n    scheduleViewUpdate()\n  })\n\n  const { stop: stopLCPTracking } = trackLargestContentfulPaint(\n    configuration,\n    firstHidden,\n    window,\n    (largestContentfulPaint) => {\n      initialViewMetrics.largestContentfulPaint = largestContentfulPaint\n      scheduleViewUpdate()\n    }\n  )\n\n  function stop() {\n    stopNavigationTracking()\n    stopFCPTracking()\n    stopLCPTracking()\n    firstHidden.stop()\n  }\n\n  return {\n    stop,\n    initialViewMetrics,\n  }\n}\n"],"mappings":";;;;;AAeA,SAAgB,wBACd,eACA,WACA,cACA,oBACA;CACA,MAAM,qBAAyC,CAAC;CAEhD,MAAM,EAAE,MAAM,2BAA2B,wBAAwB,sBAAsB;EACrF,aAAa,kBAAkB,SAAS;EACxC,mBAAmB,oBAAoB;EACvC,mBAAmB;CACrB,CAAC;CAED,MAAM,cAAc,iBAAiB,SAAS;CAC9C,MAAM,EAAE,MAAM,oBAAoB,0BAA0B,cAAc,yBAAyB;EACjG,mBAAmB,uBAAuB;EAC1C,mBAAmB;CACrB,CAAC;CAED,MAAM,EAAE,MAAM,oBAAoB,4BAChC,eACA,aACA,SACC,2BAA2B;EAC1B,mBAAmB,yBAAyB;EAC5C,mBAAmB;CACrB,CACF;CAEA,SAAS,OAAO;EACd,uBAAuB;EACvB,gBAAgB;EAChB,gBAAgB;EAChB,YAAY,KAAK;CACnB;CAEA,OAAO;EACL;EACA;CACF;AACF"}

package/esm/domain/view/viewMetrics/trackInteractionToNextPaint.mjs

@@ -0,0 +1,210 @@
+import { ViewLoadingType } from "../../../rawRumEvent.types.mjs";
+import { isElementNode } from "../../../browser/htmlDomUtils.mjs";
+import { createPerformanceObservable, supportPerformanceTimingEvent } from "../../../browser/performanceObservable.mjs";
+import { getSelectorFromElement } from "../../getSelectorFromElement.mjs";
+import { getInteractionSelector } from "../../action/interactionSelectorCache.mjs";
+import { getInteractionCount, initInteractionCountPolyfill } from "./interactionCountPolyfill.mjs";
+import { ONE_MINUTE, elapsed } from "@kubesense/kubesense-js-core/time";
+import { noop } from "@kubesense/kubesense-browser-core";
+//#region src/domain/view/viewMetrics/trackInteractionToNextPaint.ts
+const MAX_INTERACTION_ENTRIES = 10;
+const MAX_INP_VALUE = 1 * ONE_MINUTE;
+const RENDER_TIME_GROUPING_THRESHOLD = 8;
+/**
+* Track the interaction to next paint (INP).
+* To avoid outliers, return the p98 worst interaction of the view.
+* Documentation: https://web.dev/inp/
+* Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/main/src/onINP.ts
+*/
+function trackInteractionToNextPaint(configuration, viewStart, viewLoadingType) {
+	if (!isInteractionToNextPaintSupported()) return {
+		getInteractionToNextPaint: () => void 0,
+		setViewEnd: noop,
+		stop: noop
+	};
+	let viewEnd = Infinity;
+	let currentInp;
+	const { getViewInteractionCount, stopViewInteractionCount } = trackViewInteractionCount(viewLoadingType);
+	const longestInteractions = trackLongestInteractions(getViewInteractionCount);
+	const subPartsTracker = createSubPartsTracker(longestInteractions);
+	const firstInputSubscription = createPerformanceObservable({
+		type: "first-input",
+		buffered: true
+	}).subscribe(handleEntries);
+	const eventSubscription = createPerformanceObservable({
+		type: "event",
+		durationThreshold: 40,
+		buffered: true
+	}).subscribe(handleEntries);
+	function handleEntries(entries) {
+		for (const entry of entries) if (entry.interactionId && entry.startTime >= viewStart && entry.startTime <= viewEnd) {
+			longestInteractions.process(entry);
+			subPartsTracker.process(entry);
+		}
+		subPartsTracker.pruneUntracked();
+		const candidate = longestInteractions.estimateP98Interaction();
+		if (candidate) updateCurrentInp(candidate);
+	}
+	function updateCurrentInp(candidate) {
+		const newStartTime = elapsed(viewStart, candidate.startTime);
+		if (candidate.duration !== currentInp?.duration || newStartTime !== currentInp.startTime) {
+			let targetSelector = getInteractionSelector(candidate.startTime);
+			if (!targetSelector && candidate.target && isElementNode(candidate.target)) targetSelector = getSelectorFromElement(candidate.target, configuration.actionNameAttribute);
+			currentInp = {
+				duration: candidate.duration,
+				startTime: newStartTime,
+				targetSelector
+			};
+		}
+		currentInp.subParts = subPartsTracker.computeSubParts(candidate, sanitizeInpValue(currentInp.duration));
+	}
+	return {
+		getInteractionToNextPaint: () => {
+			if (currentInp) return {
+				value: sanitizeInpValue(currentInp.duration),
+				targetSelector: currentInp.targetSelector,
+				time: currentInp.startTime,
+				subParts: currentInp.subParts
+			};
+			else if (getViewInteractionCount()) return { value: 0 };
+		},
+		setViewEnd: (viewEndTime) => {
+			viewEnd = viewEndTime;
+			stopViewInteractionCount();
+		},
+		stop: () => {
+			eventSubscription.unsubscribe();
+			firstInputSubscription.unsubscribe();
+			subPartsTracker.stop();
+		}
+	};
+}
+/**
+* Maintains a bounded list of the slowest interactions seen so far, used to estimate the p98
+* interaction duration without keeping every entry in memory.
+*/
+function trackLongestInteractions(getViewInteractionCount) {
+	const longestInteractions = [];
+	function sortAndTrimLongestInteractions() {
+		longestInteractions.sort((a, b) => b.duration - a.duration).splice(MAX_INTERACTION_ENTRIES);
+	}
+	return {
+		/**
+		* Process the performance entry:
+		* - if its duration is long enough, add the performance entry to the list of worst interactions
+		* - if an entry with the same interaction id exists and its duration is lower than the new one, then replace it in the list of worst interactions
+		*/
+		process(entry) {
+			const interactionIndex = longestInteractions.findIndex((interaction) => entry.interactionId === interaction.interactionId);
+			const minLongestInteraction = longestInteractions[longestInteractions.length - 1];
+			if (interactionIndex !== -1) {
+				if (entry.duration > longestInteractions[interactionIndex].duration) {
+					longestInteractions[interactionIndex] = entry;
+					sortAndTrimLongestInteractions();
+				}
+			} else if (longestInteractions.length < MAX_INTERACTION_ENTRIES || entry.duration > minLongestInteraction.duration) {
+				longestInteractions.push(entry);
+				sortAndTrimLongestInteractions();
+			}
+		},
+		/**
+		* Compute the p98 longest interaction.
+		* For better performance the computation is based on 10 longest interactions and the interaction count of the current view.
+		*/
+		estimateP98Interaction() {
+			const interactionIndex = Math.min(longestInteractions.length - 1, Math.floor(getViewInteractionCount() / 50));
+			return longestInteractions[interactionIndex];
+		},
+		isTracked(interactionId) {
+			return longestInteractions.some((i) => i.interactionId === interactionId);
+		}
+	};
+}
+/**
+* Tracks the number of interactions that occurred during the current view. Freezes the count
+* when the view ends so that the p98 estimate remains stable after `setViewEnd` is called.
+*/
+function trackViewInteractionCount(viewLoadingType) {
+	initInteractionCountPolyfill();
+	const previousInteractionCount = viewLoadingType === ViewLoadingType.INITIAL_LOAD ? 0 : getInteractionCount();
+	let state = { stopped: false };
+	function computeViewInteractionCount() {
+		return getInteractionCount() - previousInteractionCount;
+	}
+	return {
+		getViewInteractionCount: () => {
+			if (state.stopped) return state.interactionCount;
+			return computeViewInteractionCount();
+		},
+		stopViewInteractionCount: () => {
+			state = {
+				stopped: true,
+				interactionCount: computeViewInteractionCount()
+			};
+		}
+	};
+}
+/**
+* Groups performance entries by interaction and render time to compute INP subparts
+* (input delay, processing duration, presentation delay). Entries sharing the same
+* interactionId, or whose render time falls within the 8 ms Event Timing rounding window,
+* are merged into a single group so that subparts always sum to the reported INP duration.
+*/
+function createSubPartsTracker(longestInteractions) {
+	const groupsByInteractionId = /* @__PURE__ */ new Map();
+	function updateGroupWithEntry(group, entry) {
+		group.startTime = Math.min(entry.startTime, group.startTime);
+		group.processingStart = Math.min(entry.processingStart, group.processingStart);
+		group.processingEnd = Math.max(entry.processingEnd, group.processingEnd);
+	}
+	return {
+		process(entry) {
+			if (entry.interactionId === void 0 || !entry.processingStart || !entry.processingEnd) return;
+			const renderTime = entry.startTime + entry.duration;
+			const existingGroup = groupsByInteractionId.get(entry.interactionId);
+			if (existingGroup) {
+				updateGroupWithEntry(existingGroup, entry);
+				return;
+			}
+			for (const [, group] of groupsByInteractionId.entries()) if (Math.abs(renderTime - group.referenceRenderTime) <= RENDER_TIME_GROUPING_THRESHOLD) {
+				updateGroupWithEntry(group, entry);
+				groupsByInteractionId.set(entry.interactionId, group);
+				return;
+			}
+			groupsByInteractionId.set(entry.interactionId, {
+				startTime: entry.startTime,
+				processingStart: entry.processingStart,
+				processingEnd: entry.processingEnd,
+				referenceRenderTime: renderTime
+			});
+		},
+		pruneUntracked() {
+			for (const [interactionId] of groupsByInteractionId) if (!longestInteractions.isTracked(interactionId)) groupsByInteractionId.delete(interactionId);
+		},
+		computeSubParts(entry, inpDuration) {
+			if (!entry.processingStart || !entry.processingEnd || entry.interactionId === void 0) return;
+			const group = groupsByInteractionId.get(entry.interactionId);
+			if (!group) return;
+			const nextPaintTime = Math.max(group.startTime + inpDuration, group.processingStart);
+			const processingEnd = Math.min(group.processingEnd, nextPaintTime);
+			return {
+				inputDelay: elapsed(group.startTime, group.processingStart),
+				processingDuration: elapsed(group.processingStart, processingEnd),
+				presentationDelay: elapsed(processingEnd, nextPaintTime)
+			};
+		},
+		stop() {
+			groupsByInteractionId.clear();
+		}
+	};
+}
+function isInteractionToNextPaintSupported() {
+	return supportPerformanceTimingEvent("event") && window.PerformanceEventTiming && "interactionId" in PerformanceEventTiming.prototype;
+}
+function sanitizeInpValue(inpValue) {
+	return Math.min(inpValue, MAX_INP_VALUE);
+}
+//#endregion
+export { MAX_INP_VALUE, isInteractionToNextPaintSupported, trackInteractionToNextPaint, trackViewInteractionCount };
+
+//# sourceMappingURL=trackInteractionToNextPaint.mjs.map