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

package/cjs/domain/view/viewMetrics/trackFirstHidden.js

@@ -1,33 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trackFirstHidden = trackFirstHidden;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
-const performanceObservable_1 = require("../../../browser/performanceObservable");
-function trackFirstHidden(configuration, viewStart, eventTarget = window) {
-    if (document.visibilityState === 'hidden') {
-        return { timeStamp: 0, stop: kubesense_browser_core_1.noop };
-    }
-    if ((0, performanceObservable_1.supportPerformanceTimingEvent)(performanceObservable_1.RumPerformanceEntryType.VISIBILITY_STATE)) {
-        const firstHiddenEntry = performance
-            .getEntriesByType(performanceObservable_1.RumPerformanceEntryType.VISIBILITY_STATE)
-            .filter((entry) => entry.name === 'hidden')
-            .find((entry) => entry.startTime >= viewStart.relative);
-        if (firstHiddenEntry) {
-            return { timeStamp: firstHiddenEntry.startTime, stop: kubesense_browser_core_1.noop };
-        }
-    }
-    let timeStamp = Infinity;
-    const { stop } = (0, kubesense_browser_core_1.addEventListeners)(configuration, eventTarget, ["pagehide" /* DOM_EVENT.PAGE_HIDE */, "visibilitychange" /* DOM_EVENT.VISIBILITY_CHANGE */], (event) => {
-        if (event.type === "pagehide" /* DOM_EVENT.PAGE_HIDE */ || document.visibilityState === 'hidden') {
-            timeStamp = event.timeStamp;
-            stop();
-        }
-    }, { capture: true });
-    return {
-        get timeStamp() {
-            return timeStamp;
-        },
-        stop,
-    };
+const require_performanceObservable = require("../../../browser/performanceObservable.js");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+//#region src/domain/view/viewMetrics/trackFirstHidden.ts
+function trackFirstHidden(viewStart, eventTarget = window) {
+	if (document.visibilityState === "hidden") return {
+		timeStamp: 0,
+		stop: _kubesense_kubesense_browser_core.noop
+	};
+	if (require_performanceObservable.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: _kubesense_kubesense_browser_core.noop
+		};
+	}
+	let timeStamp = Infinity;
+	const { stop } = (0, _kubesense_kubesense_browser_core.addEventListeners)(eventTarget, [_kubesense_kubesense_browser_core.DOM_EVENT.PAGE_HIDE, _kubesense_kubesense_browser_core.DOM_EVENT.VISIBILITY_CHANGE], (event) => {
+		if (event.type === _kubesense_kubesense_browser_core.DOM_EVENT.PAGE_HIDE || document.visibilityState === "hidden") {
+			timeStamp = event.timeStamp;
+			stop();
+		}
+	}, { capture: true });
+	return {
+		get timeStamp() {
+			return timeStamp;
+		},
+		stop
+	};
 }
+//#endregion
+exports.trackFirstHidden = trackFirstHidden;
+
 //# sourceMappingURL=trackFirstHidden.js.map

package/cjs/domain/view/viewMetrics/trackFirstHidden.js.map

@@ -1 +1 @@
-{"version":3,"file":"trackFirstHidden.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackFirstHidden.ts"],"names":[],"mappings":";;AAWA,4CAyCC;AAnDD,8EAAsF;AAEtF,kFAA+G;AAQ/G,SAAgB,gBAAgB,CAC9B,aAA+B,EAC/B,SAAsB,EACtB,cAAsB,MAAM;IAE5B,IAAI,QAAQ,CAAC,eAAe,KAAK,QAAQ,EAAE,CAAC;QAC1C,OAAO,EAAE,SAAS,EAAE,CAAiB,EAAE,IAAI,EAAE,6BAAI,EAAE,CAAA;IACrD,CAAC;IAED,IAAI,IAAA,qDAA6B,EAAC,+CAAuB,CAAC,gBAAgB,CAAC,EAAE,CAAC;QAC5E,MAAM,gBAAgB,GAAG,WAAW;aACjC,gBAAgB,CAAC,+CAAuB,CAAC,gBAAgB,CAAC;aAC1D,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC;aAC1C,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,IAAI,SAAS,CAAC,QAAQ,CAAC,CAAA;QAEzD,IAAI,gBAAgB,EAAE,CAAC;YACrB,OAAO,EAAE,SAAS,EAAE,gBAAgB,CAAC,SAAyB,EAAE,IAAI,EAAE,6BAAI,EAAE,CAAA;QAC9E,CAAC;IACH,CAAC;IAED,IAAI,SAAS,GAAiB,QAAwB,CAAA;IAEtD,MAAM,EAAE,IAAI,EAAE,GAAG,IAAA,0CAAiB,EAChC,aAAa,EACb,WAAW,EACX,4FAAkD,EAClD,CAAC,KAAK,EAAE,EAAE;QACR,IAAI,KAAK,CAAC,IAAI,yCAAwB,IAAI,QAAQ,CAAC,eAAe,KAAK,QAAQ,EAAE,CAAC;YAChF,SAAS,GAAG,KAAK,CAAC,SAAyB,CAAA;YAC3C,IAAI,EAAE,CAAA;QACR,CAAC;IACH,CAAC,EACD,EAAE,OAAO,EAAE,IAAI,EAAE,CAClB,CAAA;IAED,OAAO;QACL,IAAI,SAAS;YACX,OAAO,SAAS,CAAA;QAClB,CAAC;QACD,IAAI;KACL,CAAA;AACH,CAAC"}
+{"version":3,"file":"trackFirstHidden.js","names":["noop","supportPerformanceTimingEvent","addEventListeners","DOM_EVENT"],"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,MAAMA,kCAAAA;CAAK;CAGpD,IAAIC,8BAAAA,8BAAAA,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,MAAMD,kCAAAA;EAAK;CAE/E;CAEA,IAAI,YAA0B;CAE9B,MAAM,EAAE,UAAA,GAASE,kCAAAA,kBAAAA,CACf,aACA,CAACC,kCAAAA,UAAU,WAAWA,kCAAAA,UAAU,iBAAiB,IAChD,UAAU;EACT,IAAI,MAAM,SAASA,kCAAAA,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/cjs/domain/view/viewMetrics/trackInitialViewMetrics.d.ts

@@ -1,13 +1,11 @@
-import type { ClocksState, Duration } from '@kubesense/kubesense-browser-core';
+import type { ClocksState, Duration } from '@kubesense/kubesense-js-core/time';
 import type { RumConfiguration } from '../../configuration';
-import type { FirstInput } from './trackFirstInput';
 import type { NavigationTimings } from './trackNavigationTimings';
 import type { LargestContentfulPaint } from './trackLargestContentfulPaint';
 export interface InitialViewMetrics {
     firstContentfulPaint?: Duration;
     navigationTimings?: NavigationTimings;
     largestContentfulPaint?: LargestContentfulPaint;
-    firstInput?: FirstInput;
 }
 export declare function trackInitialViewMetrics(configuration: RumConfiguration, viewStart: ClocksState, setLoadEvent: (loadEnd: Duration) => void, scheduleViewUpdate: () => void): {
     stop: () => void;

package/cjs/domain/view/viewMetrics/trackInitialViewMetrics.js

@@ -1,41 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trackInitialViewMetrics = trackInitialViewMetrics;
-const trackFirstContentfulPaint_1 = require("./trackFirstContentfulPaint");
-const trackFirstInput_1 = require("./trackFirstInput");
-const trackNavigationTimings_1 = require("./trackNavigationTimings");
-const trackLargestContentfulPaint_1 = require("./trackLargestContentfulPaint");
-const trackFirstHidden_1 = require("./trackFirstHidden");
+const require_trackFirstContentfulPaint = require("./trackFirstContentfulPaint.js");
+const require_trackNavigationTimings = require("./trackNavigationTimings.js");
+const require_trackLargestContentfulPaint = require("./trackLargestContentfulPaint.js");
+const require_trackFirstHidden = require("./trackFirstHidden.js");
+//#region src/domain/view/viewMetrics/trackInitialViewMetrics.ts
 function trackInitialViewMetrics(configuration, viewStart, setLoadEvent, scheduleViewUpdate) {
-    const initialViewMetrics = {};
-    const { stop: stopNavigationTracking } = (0, trackNavigationTimings_1.trackNavigationTimings)(configuration, (navigationTimings) => {
-        setLoadEvent(navigationTimings.loadEvent);
-        initialViewMetrics.navigationTimings = navigationTimings;
-        scheduleViewUpdate();
-    });
-    const firstHidden = (0, trackFirstHidden_1.trackFirstHidden)(configuration, viewStart);
-    const { stop: stopFCPTracking } = (0, trackFirstContentfulPaint_1.trackFirstContentfulPaint)(configuration, firstHidden, (firstContentfulPaint) => {
-        initialViewMetrics.firstContentfulPaint = firstContentfulPaint;
-        scheduleViewUpdate();
-    });
-    const { stop: stopLCPTracking } = (0, trackLargestContentfulPaint_1.trackLargestContentfulPaint)(configuration, firstHidden, window, (largestContentfulPaint) => {
-        initialViewMetrics.largestContentfulPaint = largestContentfulPaint;
-        scheduleViewUpdate();
-    });
-    const { stop: stopFIDTracking } = (0, trackFirstInput_1.trackFirstInput)(configuration, firstHidden, (firstInput) => {
-        initialViewMetrics.firstInput = firstInput;
-        scheduleViewUpdate();
-    });
-    function stop() {
-        stopNavigationTracking();
-        stopFCPTracking();
-        stopLCPTracking();
-        stopFIDTracking();
-        firstHidden.stop();
-    }
-    return {
-        stop,
-        initialViewMetrics,
-    };
+	const initialViewMetrics = {};
+	const { stop: stopNavigationTracking } = require_trackNavigationTimings.trackNavigationTimings((navigationTimings) => {
+		setLoadEvent(navigationTimings.loadEvent);
+		initialViewMetrics.navigationTimings = navigationTimings;
+		scheduleViewUpdate();
+	});
+	const firstHidden = require_trackFirstHidden.trackFirstHidden(viewStart);
+	const { stop: stopFCPTracking } = require_trackFirstContentfulPaint.trackFirstContentfulPaint(firstHidden, (firstContentfulPaint) => {
+		initialViewMetrics.firstContentfulPaint = firstContentfulPaint;
+		scheduleViewUpdate();
+	});
+	const { stop: stopLCPTracking } = require_trackLargestContentfulPaint.trackLargestContentfulPaint(configuration, firstHidden, window, (largestContentfulPaint) => {
+		initialViewMetrics.largestContentfulPaint = largestContentfulPaint;
+		scheduleViewUpdate();
+	});
+	function stop() {
+		stopNavigationTracking();
+		stopFCPTracking();
+		stopLCPTracking();
+		firstHidden.stop();
+	}
+	return {
+		stop,
+		initialViewMetrics
+	};
 }
+//#endregion
+exports.trackInitialViewMetrics = trackInitialViewMetrics;
+
 //# sourceMappingURL=trackInitialViewMetrics.js.map

package/cjs/domain/view/viewMetrics/trackInitialViewMetrics.js.map

@@ -1 +1 @@
-{"version":3,"file":"trackInitialViewMetrics.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackInitialViewMetrics.ts"],"names":[],"mappings":";;AAkBA,0DA+CC;AA/DD,2EAAuE;AAEvE,uDAAmD;AAEnD,qEAAiE;AAEjE,+EAA2E;AAC3E,yDAAqD;AASrD,SAAgB,uBAAuB,CACrC,aAA+B,EAC/B,SAAsB,EACtB,YAAyC,EACzC,kBAA8B;IAE9B,MAAM,kBAAkB,GAAuB,EAAE,CAAA;IAEjD,MAAM,EAAE,IAAI,EAAE,sBAAsB,EAAE,GAAG,IAAA,+CAAsB,EAAC,aAAa,EAAE,CAAC,iBAAiB,EAAE,EAAE;QACnG,YAAY,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAA;QACzC,kBAAkB,CAAC,iBAAiB,GAAG,iBAAiB,CAAA;QACxD,kBAAkB,EAAE,CAAA;IACtB,CAAC,CAAC,CAAA;IAEF,MAAM,WAAW,GAAG,IAAA,mCAAgB,EAAC,aAAa,EAAE,SAAS,CAAC,CAAA;IAC9D,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,GAAG,IAAA,qDAAyB,EAAC,aAAa,EAAE,WAAW,EAAE,CAAC,oBAAoB,EAAE,EAAE;QAC/G,kBAAkB,CAAC,oBAAoB,GAAG,oBAAoB,CAAA;QAC9D,kBAAkB,EAAE,CAAA;IACtB,CAAC,CAAC,CAAA;IAEF,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,GAAG,IAAA,yDAA2B,EAC3D,aAAa,EACb,WAAW,EACX,MAAM,EACN,CAAC,sBAAsB,EAAE,EAAE;QACzB,kBAAkB,CAAC,sBAAsB,GAAG,sBAAsB,CAAA;QAClE,kBAAkB,EAAE,CAAA;IACtB,CAAC,CACF,CAAA;IAED,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,GAAG,IAAA,iCAAe,EAAC,aAAa,EAAE,WAAW,EAAE,CAAC,UAAU,EAAE,EAAE;QAC3F,kBAAkB,CAAC,UAAU,GAAG,UAAU,CAAA;QAC1C,kBAAkB,EAAE,CAAA;IACtB,CAAC,CAAC,CAAA;IAEF,SAAS,IAAI;QACX,sBAAsB,EAAE,CAAA;QACxB,eAAe,EAAE,CAAA;QACjB,eAAe,EAAE,CAAA;QACjB,eAAe,EAAE,CAAA;QACjB,WAAW,CAAC,IAAI,EAAE,CAAA;IACpB,CAAC;IAED,OAAO;QACL,IAAI;QACJ,kBAAkB;KACnB,CAAA;AACH,CAAC"}
+{"version":3,"file":"trackInitialViewMetrics.js","names":["trackNavigationTimings","trackFirstHidden","trackFirstContentfulPaint","trackLargestContentfulPaint"],"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,2BAA2BA,+BAAAA,wBAAwB,sBAAsB;EACrF,aAAa,kBAAkB,SAAS;EACxC,mBAAmB,oBAAoB;EACvC,mBAAmB;CACrB,CAAC;CAED,MAAM,cAAcC,yBAAAA,iBAAiB,SAAS;CAC9C,MAAM,EAAE,MAAM,oBAAoBC,kCAAAA,0BAA0B,cAAc,yBAAyB;EACjG,mBAAmB,uBAAuB;EAC1C,mBAAmB;CACrB,CAAC;CAED,MAAM,EAAE,MAAM,oBAAoBC,oCAAAA,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/cjs/domain/view/viewMetrics/trackInteractionToNextPaint.d.ts

@@ -1,4 +1,4 @@
-import type { Duration, RelativeTime } from '@kubesense/kubesense-browser-core';
+import type { RelativeTime, Duration } from '@kubesense/kubesense-js-core/time';
 import { ViewLoadingType } from '../../../rawRumEvent.types';
 import type { RumConfiguration } from '../../configuration';
 export declare const MAX_INP_VALUE: Duration;
@@ -6,6 +6,11 @@ export interface InteractionToNextPaint {
     value: Duration;
     targetSelector?: string;
     time?: Duration;
+    subParts?: {
+        inputDelay: Duration;
+        processingDuration: Duration;
+        presentationDelay: Duration;
+    };
 }
 /**
  * Track the interaction to next paint (INP).
@@ -18,6 +23,10 @@ export declare function trackInteractionToNextPaint(configuration: RumConfigurat
     setViewEnd: (viewEndTime: RelativeTime) => void;
     stop: () => void;
 };
+/**
+ * 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.
+ */
 export declare function trackViewInteractionCount(viewLoadingType: ViewLoadingType): {
     getViewInteractionCount: () => number;
     stopViewInteractionCount: () => void;

package/cjs/domain/view/viewMetrics/trackInteractionToNextPaint.js

@@ -1,155 +1,213 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_INP_VALUE = void 0;
-exports.trackInteractionToNextPaint = trackInteractionToNextPaint;
-exports.trackViewInteractionCount = trackViewInteractionCount;
-exports.isInteractionToNextPaintSupported = isInteractionToNextPaintSupported;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
-const performanceObservable_1 = require("../../../browser/performanceObservable");
-const rawRumEvent_types_1 = require("../../../rawRumEvent.types");
-const getSelectorFromElement_1 = require("../../getSelectorFromElement");
-const htmlDomUtils_1 = require("../../../browser/htmlDomUtils");
-const interactionSelectorCache_1 = require("../../action/interactionSelectorCache");
-const interactionCountPolyfill_1 = require("./interactionCountPolyfill");
-// Arbitrary value to prevent unnecessary memory usage on views with lots of interactions.
+const require_rawRumEvent_types = require("../../../rawRumEvent.types.js");
+const require_htmlDomUtils = require("../../../browser/htmlDomUtils.js");
+const require_performanceObservable = require("../../../browser/performanceObservable.js");
+const require_getSelectorFromElement = require("../../getSelectorFromElement.js");
+const require_interactionSelectorCache = require("../../action/interactionSelectorCache.js");
+const require_interactionCountPolyfill = require("./interactionCountPolyfill.js");
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+//#region src/domain/view/viewMetrics/trackInteractionToNextPaint.ts
 const MAX_INTERACTION_ENTRIES = 10;
-// Arbitrary value to cap INP outliers
-exports.MAX_INP_VALUE = (1 * kubesense_browser_core_1.ONE_MINUTE);
+const MAX_INP_VALUE = 1 * _kubesense_kubesense_js_core_time.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
- */
+* 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: () => undefined,
-            setViewEnd: kubesense_browser_core_1.noop,
-            stop: kubesense_browser_core_1.noop,
-        };
-    }
-    const { getViewInteractionCount, stopViewInteractionCount } = trackViewInteractionCount(viewLoadingType);
-    let viewEnd = Infinity;
-    const longestInteractions = trackLongestInteractions(getViewInteractionCount);
-    let interactionToNextPaint = -1;
-    let interactionToNextPaintTargetSelector;
-    let interactionToNextPaintStartTime;
-    function handleEntries(entries) {
-        for (const entry of entries) {
-            if (entry.interactionId &&
-                // Check the entry start time is inside the view bounds because some view interactions can be reported after the view end (if long duration).
-                entry.startTime >= viewStart &&
-                entry.startTime <= viewEnd) {
-                longestInteractions.process(entry);
-            }
-        }
-        const newInteraction = longestInteractions.estimateP98Interaction();
-        if (newInteraction && newInteraction.duration !== interactionToNextPaint) {
-            interactionToNextPaint = newInteraction.duration;
-            interactionToNextPaintStartTime = (0, kubesense_browser_core_1.elapsed)(viewStart, newInteraction.startTime);
-            interactionToNextPaintTargetSelector = (0, interactionSelectorCache_1.getInteractionSelector)(newInteraction.startTime);
-            if (!interactionToNextPaintTargetSelector && newInteraction.target && (0, htmlDomUtils_1.isElementNode)(newInteraction.target)) {
-                interactionToNextPaintTargetSelector = (0, getSelectorFromElement_1.getSelectorFromElement)(newInteraction.target, configuration.actionNameAttribute);
-            }
-        }
-    }
-    const firstInputSubscription = (0, performanceObservable_1.createPerformanceObservable)(configuration, {
-        type: performanceObservable_1.RumPerformanceEntryType.FIRST_INPUT,
-        buffered: true,
-    }).subscribe(handleEntries);
-    const eventSubscription = (0, performanceObservable_1.createPerformanceObservable)(configuration, {
-        type: performanceObservable_1.RumPerformanceEntryType.EVENT,
-        // durationThreshold only impact PerformanceEventTiming entries used for INP computation which requires a threshold at 40 (default is 104ms)
-        // cf: https://github.com/GoogleChrome/web-vitals/blob/3806160ffbc93c3c4abf210a167b81228172b31c/src/onINP.ts#L202-L210
-        durationThreshold: 40,
-        buffered: true,
-    }).subscribe(handleEntries);
-    return {
-        getInteractionToNextPaint: () => {
-            // If no INP duration where captured because of the performanceObserver 40ms threshold
-            // but the view interaction count > 0 then report 0
-            if (interactionToNextPaint >= 0) {
-                return {
-                    value: Math.min(interactionToNextPaint, exports.MAX_INP_VALUE),
-                    targetSelector: interactionToNextPaintTargetSelector,
-                    time: interactionToNextPaintStartTime,
-                };
-            }
-            else if (getViewInteractionCount()) {
-                return {
-                    value: 0,
-                };
-            }
-        },
-        setViewEnd: (viewEndTime) => {
-            viewEnd = viewEndTime;
-            stopViewInteractionCount();
-        },
-        stop: () => {
-            eventSubscription.unsubscribe();
-            firstInputSubscription.unsubscribe();
-        },
-    };
+	if (!isInteractionToNextPaintSupported()) return {
+		getInteractionToNextPaint: () => void 0,
+		setViewEnd: _kubesense_kubesense_browser_core.noop,
+		stop: _kubesense_kubesense_browser_core.noop
+	};
+	let viewEnd = Infinity;
+	let currentInp;
+	const { getViewInteractionCount, stopViewInteractionCount } = trackViewInteractionCount(viewLoadingType);
+	const longestInteractions = trackLongestInteractions(getViewInteractionCount);
+	const subPartsTracker = createSubPartsTracker(longestInteractions);
+	const firstInputSubscription = require_performanceObservable.createPerformanceObservable({
+		type: "first-input",
+		buffered: true
+	}).subscribe(handleEntries);
+	const eventSubscription = require_performanceObservable.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 = (0, _kubesense_kubesense_js_core_time.elapsed)(viewStart, candidate.startTime);
+		if (candidate.duration !== currentInp?.duration || newStartTime !== currentInp.startTime) {
+			let targetSelector = require_interactionSelectorCache.getInteractionSelector(candidate.startTime);
+			if (!targetSelector && candidate.target && require_htmlDomUtils.isElementNode(candidate.target)) targetSelector = require_getSelectorFromElement.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];
-        },
-    };
+	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) {
-    (0, interactionCountPolyfill_1.initInteractionCountPolyfill)();
-    const previousInteractionCount = viewLoadingType === rawRumEvent_types_1.ViewLoadingType.INITIAL_LOAD ? 0 : (0, interactionCountPolyfill_1.getInteractionCount)();
-    let state = { stopped: false };
-    function computeViewInteractionCount() {
-        return (0, interactionCountPolyfill_1.getInteractionCount)() - previousInteractionCount;
-    }
-    return {
-        getViewInteractionCount: () => {
-            if (state.stopped) {
-                return state.interactionCount;
-            }
-            return computeViewInteractionCount();
-        },
-        stopViewInteractionCount: () => {
-            state = { stopped: true, interactionCount: computeViewInteractionCount() };
-        },
-    };
+	require_interactionCountPolyfill.initInteractionCountPolyfill();
+	const previousInteractionCount = viewLoadingType === require_rawRumEvent_types.ViewLoadingType.INITIAL_LOAD ? 0 : require_interactionCountPolyfill.getInteractionCount();
+	let state = { stopped: false };
+	function computeViewInteractionCount() {
+		return require_interactionCountPolyfill.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: (0, _kubesense_kubesense_js_core_time.elapsed)(group.startTime, group.processingStart),
+				processingDuration: (0, _kubesense_kubesense_js_core_time.elapsed)(group.processingStart, processingEnd),
+				presentationDelay: (0, _kubesense_kubesense_js_core_time.elapsed)(processingEnd, nextPaintTime)
+			};
+		},
+		stop() {
+			groupsByInteractionId.clear();
+		}
+	};
 }
 function isInteractionToNextPaintSupported() {
-    return ((0, performanceObservable_1.supportPerformanceTimingEvent)(performanceObservable_1.RumPerformanceEntryType.EVENT) &&
-        window.PerformanceEventTiming &&
-        'interactionId' in PerformanceEventTiming.prototype);
+	return require_performanceObservable.supportPerformanceTimingEvent("event") && window.PerformanceEventTiming && "interactionId" in PerformanceEventTiming.prototype;
+}
+function sanitizeInpValue(inpValue) {
+	return Math.min(inpValue, MAX_INP_VALUE);
 }
+//#endregion
+exports.MAX_INP_VALUE = MAX_INP_VALUE;
+exports.isInteractionToNextPaintSupported = isInteractionToNextPaintSupported;
+exports.trackInteractionToNextPaint = trackInteractionToNextPaint;
+exports.trackViewInteractionCount = trackViewInteractionCount;
+
 //# sourceMappingURL=trackInteractionToNextPaint.js.map