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

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

@@ -1,17 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trackBfcacheMetrics = trackBfcacheMetrics;
-const trackFirstContentfulPaint_1 = require("./trackFirstContentfulPaint");
+const require_trackFirstContentfulPaint = require("./trackFirstContentfulPaint.js");
+//#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)
- */
+* 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) {
-    (0, trackFirstContentfulPaint_1.trackRestoredFirstContentfulPaint)(viewStart.relative, (paintTime) => {
-        metrics.firstContentfulPaint = paintTime;
-        metrics.largestContentfulPaint = { value: paintTime };
-        scheduleViewUpdate();
-    });
+	require_trackFirstContentfulPaint.trackRestoredFirstContentfulPaint(viewStart.relative, (paintTime) => {
+		metrics.firstContentfulPaint = paintTime;
+		metrics.largestContentfulPaint = { value: paintTime };
+		scheduleViewUpdate();
+	});
 }
+//#endregion
+exports.trackBfcacheMetrics = trackBfcacheMetrics;
+
 //# sourceMappingURL=trackBfcacheMetrics.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"trackBfcacheMetrics.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackBfcacheMetrics.ts"],"names":[],"mappings":";;AASA,kDAUC;AAjBD,2EAA+E;AAE/E;;;;GAIG;AACH,SAAgB,mBAAmB,CACjC,SAAsB,EACtB,OAA2B,EAC3B,kBAA8B;IAE9B,IAAA,6DAAiC,EAAC,SAAS,CAAC,QAAQ,EAAE,CAAC,SAAS,EAAE,EAAE;QAClE,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAA;QACxC,OAAO,CAAC,sBAAsB,GAAG,EAAE,KAAK,EAAE,SAAyB,EAAE,CAAA;QACrE,kBAAkB,EAAE,CAAA;IACtB,CAAC,CAAC,CAAA;AACJ,CAAC"}
+{"version":3,"file":"trackBfcacheMetrics.js","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,kCAAA,kCAAkC,UAAU,WAAW,cAAc;EACnE,QAAQ,uBAAuB;EAC/B,QAAQ,yBAAyB,EAAE,OAAO,UAA0B;EACpE,mBAAmB;CACrB,CAAC;AACH"}

package/cjs/domain/view/viewMetrics/trackCommonViewMetrics.d.ts

@@ -1,4 +1,5 @@
-import type { ClocksState, Duration, Observable } from '@kubesense/kubesense-browser-core';
+import type { ClocksState, RelativeTime, Duration, TimeStamp } from '@kubesense/kubesense-js-core/time';
+import type { Observable } from '@kubesense/kubesense-browser-core';
 import type { ViewLoadingType } from '../../../rawRumEvent.types';
 import type { RumConfiguration } from '../../configuration';
 import type { LifeCycle } from '../../lifeCycle';
@@ -16,6 +17,7 @@ export declare function trackCommonViewMetrics(lifeCycle: LifeCycle, domMutation
     stop: () => void;
     stopINPTracking: () => void;
     setLoadEvent: (loadEvent: Duration) => void;
-    setViewEnd: (viewEndTime: import("@kubesense/kubesense-browser-core").RelativeTime) => void;
+    setViewEnd: (viewEndTime: RelativeTime) => void;
     getCommonViewMetrics: () => CommonViewMetrics;
+    setLoadingTime: (callTimestamp?: TimeStamp) => void;
 };

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

@@ -1,37 +1,54 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trackCommonViewMetrics = trackCommonViewMetrics;
-const trackCumulativeLayoutShift_1 = require("./trackCumulativeLayoutShift");
-const trackInteractionToNextPaint_1 = require("./trackInteractionToNextPaint");
-const trackLoadingTime_1 = require("./trackLoadingTime");
-const trackScrollMetrics_1 = require("./trackScrollMetrics");
+const require_trackCumulativeLayoutShift = require("./trackCumulativeLayoutShift.js");
+const require_trackInteractionToNextPaint = require("./trackInteractionToNextPaint.js");
+const require_trackLoadingTime = require("./trackLoadingTime.js");
+const require_trackScrollMetrics = require("./trackScrollMetrics.js");
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+//#region src/domain/view/viewMetrics/trackCommonViewMetrics.ts
 function trackCommonViewMetrics(lifeCycle, domMutationObservable, windowOpenObservable, configuration, scheduleViewUpdate, loadingType, viewStart) {
-    const commonViewMetrics = {};
-    const { stop: stopLoadingTimeTracking, setLoadEvent } = (0, trackLoadingTime_1.trackLoadingTime)(lifeCycle, domMutationObservable, windowOpenObservable, configuration, loadingType, viewStart, (newLoadingTime) => {
-        commonViewMetrics.loadingTime = newLoadingTime;
-        scheduleViewUpdate();
-    });
-    const { stop: stopScrollMetricsTracking } = (0, trackScrollMetrics_1.trackScrollMetrics)(configuration, viewStart, (newScrollMetrics) => {
-        commonViewMetrics.scroll = newScrollMetrics;
-    });
-    const { stop: stopCLSTracking } = (0, trackCumulativeLayoutShift_1.trackCumulativeLayoutShift)(configuration, viewStart.relative, (cumulativeLayoutShift) => {
-        commonViewMetrics.cumulativeLayoutShift = cumulativeLayoutShift;
-        scheduleViewUpdate();
-    });
-    const { stop: stopINPTracking, getInteractionToNextPaint, setViewEnd, } = (0, trackInteractionToNextPaint_1.trackInteractionToNextPaint)(configuration, viewStart.relative, loadingType);
-    return {
-        stop: () => {
-            stopLoadingTimeTracking();
-            stopCLSTracking();
-            stopScrollMetricsTracking();
-        },
-        stopINPTracking,
-        setLoadEvent,
-        setViewEnd,
-        getCommonViewMetrics: () => {
-            commonViewMetrics.interactionToNextPaint = getInteractionToNextPaint();
-            return commonViewMetrics;
-        },
-    };
+	const commonViewMetrics = {};
+	let hasManualLoadingTime = false;
+	let viewEnded = false;
+	const { stop: stopLoadingTimeTracking, setLoadEvent } = require_trackLoadingTime.trackLoadingTime(lifeCycle, domMutationObservable, windowOpenObservable, configuration, loadingType, viewStart, (newLoadingTime) => {
+		if (!hasManualLoadingTime) {
+			commonViewMetrics.loadingTime = newLoadingTime;
+			scheduleViewUpdate();
+		}
+	});
+	const { stop: stopScrollMetricsTracking } = require_trackScrollMetrics.trackScrollMetrics(viewStart, (newScrollMetrics) => {
+		commonViewMetrics.scroll = newScrollMetrics;
+	});
+	const { stop: stopCLSTracking } = require_trackCumulativeLayoutShift.trackCumulativeLayoutShift(configuration, viewStart.relative, (cumulativeLayoutShift) => {
+		commonViewMetrics.cumulativeLayoutShift = cumulativeLayoutShift;
+		scheduleViewUpdate();
+	});
+	const { stop: stopINPTracking, getInteractionToNextPaint, setViewEnd: setINPViewEnd } = require_trackInteractionToNextPaint.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 = (0, _kubesense_kubesense_js_core_time.elapsed)(viewStart.timeStamp, callTimestamp ?? (0, _kubesense_kubesense_js_core_time.timeStampNow)());
+			if (!hasManualLoadingTime) stopLoadingTimeTracking();
+			hasManualLoadingTime = true;
+			commonViewMetrics.loadingTime = loadingTime;
+			scheduleViewUpdate();
+		}
+	};
 }
+//#endregion
+exports.trackCommonViewMetrics = trackCommonViewMetrics;
+
 //# sourceMappingURL=trackCommonViewMetrics.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"trackCommonViewMetrics.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackCommonViewMetrics.ts"],"names":[],"mappings":";;AAoBA,wDAyDC;AAvED,6EAAyE;AAEzE,+EAA2E;AAC3E,yDAAqD;AAErD,6DAAyD;AASzD,SAAgB,sBAAsB,CACpC,SAAoB,EACpB,qBAAsD,EACtD,oBAAsC,EACtC,aAA+B,EAC/B,kBAA8B,EAC9B,WAA4B,EAC5B,SAAsB;IAEtB,MAAM,iBAAiB,GAAsB,EAAE,CAAA;IAE/C,MAAM,EAAE,IAAI,EAAE,uBAAuB,EAAE,YAAY,EAAE,GAAG,IAAA,mCAAgB,EACtE,SAAS,EACT,qBAAqB,EACrB,oBAAoB,EACpB,aAAa,EACb,WAAW,EACX,SAAS,EACT,CAAC,cAAc,EAAE,EAAE;QACjB,iBAAiB,CAAC,WAAW,GAAG,cAAc,CAAA;QAC9C,kBAAkB,EAAE,CAAA;IACtB,CAAC,CACF,CAAA;IAED,MAAM,EAAE,IAAI,EAAE,yBAAyB,EAAE,GAAG,IAAA,uCAAkB,EAAC,aAAa,EAAE,SAAS,EAAE,CAAC,gBAAgB,EAAE,EAAE;QAC5G,iBAAiB,CAAC,MAAM,GAAG,gBAAgB,CAAA;IAC7C,CAAC,CAAC,CAAA;IAEF,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,GAAG,IAAA,uDAA0B,EAC1D,aAAa,EACb,SAAS,CAAC,QAAQ,EAClB,CAAC,qBAAqB,EAAE,EAAE;QACxB,iBAAiB,CAAC,qBAAqB,GAAG,qBAAqB,CAAA;QAC/D,kBAAkB,EAAE,CAAA;IACtB,CAAC,CACF,CAAA;IAED,MAAM,EACJ,IAAI,EAAE,eAAe,EACrB,yBAAyB,EACzB,UAAU,GACX,GAAG,IAAA,yDAA2B,EAAC,aAAa,EAAE,SAAS,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAA;IAE/E,OAAO;QACL,IAAI,EAAE,GAAG,EAAE;YACT,uBAAuB,EAAE,CAAA;YACzB,eAAe,EAAE,CAAA;YACjB,yBAAyB,EAAE,CAAA;QAC7B,CAAC;QACD,eAAe;QACf,YAAY;QACZ,UAAU;QACV,oBAAoB,EAAE,GAAG,EAAE;YACzB,iBAAiB,CAAC,sBAAsB,GAAG,yBAAyB,EAAE,CAAA;YACtE,OAAO,iBAAiB,CAAA;QAC1B,CAAC;KACF,CAAA;AACH,CAAC"}
+{"version":3,"file":"trackCommonViewMetrics.js","names":["trackLoadingTime","trackScrollMetrics","trackCumulativeLayoutShift","trackInteractionToNextPaint","elapsed","timeStampNow"],"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,iBAAiBA,yBAAAA,iBACtD,WACA,uBACA,sBACA,eACA,aACA,YACC,mBAAmB;EAClB,IAAI,CAAC,sBAAsB;GACzB,kBAAkB,cAAc;GAChC,mBAAmB;EACrB;CACF,CACF;CAEA,MAAM,EAAE,MAAM,8BAA8BC,2BAAAA,mBAAmB,YAAY,qBAAqB;EAC9F,kBAAkB,SAAS;CAC7B,CAAC;CAED,MAAM,EAAE,MAAM,oBAAoBC,mCAAAA,2BAChC,eACA,UAAU,WACT,0BAA0B;EACzB,kBAAkB,wBAAwB;EAC1C,mBAAmB;CACrB,CACF;CAEA,MAAM,EACJ,MAAM,iBACN,2BACA,YAAY,kBACVC,oCAAAA,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,eAAA,GAAcC,kCAAAA,QAAAA,CAAQ,UAAU,WAAW,kBAAA,GAAiBC,kCAAAA,aAAAA,CAAa,CAAC;GAChF,IAAI,CAAC,sBACH,wBAAwB;GAE1B,uBAAuB;GACvB,kBAAkB,cAAc;GAChC,mBAAmB;EACrB;CACF;AACF"}

package/cjs/domain/view/viewMetrics/trackCumulativeLayoutShift.d.ts

@@ -1,5 +1,5 @@
 import { noop } from '@kubesense/kubesense-browser-core';
-import type { Duration, RelativeTime } from '@kubesense/kubesense-browser-core';
+import type { Duration, RelativeTime } from '@kubesense/kubesense-js-core/time';
 import type { RumConfiguration } from '../../configuration';
 import type { RumRect } from '../../../rumEvent.types';
 export interface CumulativeLayoutShift {

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

@@ -1,135 +1,119 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_WINDOW_DURATION = void 0;
-exports.trackCumulativeLayoutShift = trackCumulativeLayoutShift;
-exports.isLayoutShiftSupported = isLayoutShiftSupported;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
-const htmlDomUtils_1 = require("../../../browser/htmlDomUtils");
-const performanceObservable_1 = require("../../../browser/performanceObservable");
-const getSelectorFromElement_1 = require("../../getSelectorFromElement");
-const getClsAttributionImpactedArea_1 = require("./getClsAttributionImpactedArea");
+const require_htmlDomUtils = require("../../../browser/htmlDomUtils.js");
+const require_performanceObservable = require("../../../browser/performanceObservable.js");
+const require_getSelectorFromElement = require("../../getSelectorFromElement.js");
+const require_getClsAttributionImpactedArea = require("./getClsAttributionImpactedArea.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/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
- */
+* 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: kubesense_browser_core_1.noop,
-        };
-    }
-    let maxClsValue = 0;
-    let biggestShift;
-    // if no layout shift happen the value should be reported as 0
-    callback({
-        value: 0,
-    });
-    const slidingWindow = slidingSessionWindow();
-    const performanceSubscription = (0, performanceObservable_1.createPerformanceObservable)(configuration, {
-        type: performanceObservable_1.RumPerformanceEntryType.LAYOUT_SHIFT,
-        buffered: true,
-    }).subscribe((entries) => {
-        var _a;
-        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 === null || attribution === void 0 ? void 0 : attribution.node) ? new WeakRef(attribution.node) : undefined,
-                    time: (0, kubesense_browser_core_1.elapsed)(viewStart, entry.startTime),
-                    previousRect: attribution === null || attribution === void 0 ? void 0 : attribution.previousRect,
-                    currentRect: attribution === null || attribution === void 0 ? void 0 : attribution.currentRect,
-                    devicePixelRatio: window.devicePixelRatio,
-                };
-            }
-            if (cumulatedValue > maxClsValue) {
-                maxClsValue = cumulatedValue;
-                const target = (_a = biggestShift === null || biggestShift === void 0 ? void 0 : biggestShift.target) === null || _a === void 0 ? void 0 : _a.deref();
-                callback({
-                    value: (0, kubesense_browser_core_1.round)(maxClsValue, 4),
-                    targetSelector: target && (0, getSelectorFromElement_1.getSelectorFromElement)(target, configuration.actionNameAttribute),
-                    time: biggestShift === null || biggestShift === void 0 ? void 0 : biggestShift.time,
-                    previousRect: (biggestShift === null || biggestShift === void 0 ? void 0 : biggestShift.previousRect) ? asRumRect(biggestShift.previousRect) : undefined,
-                    currentRect: (biggestShift === null || biggestShift === void 0 ? void 0 : biggestShift.currentRect) ? asRumRect(biggestShift.currentRect) : undefined,
-                    devicePixelRatio: biggestShift === null || biggestShift === void 0 ? void 0 : biggestShift.devicePixelRatio,
-                });
-            }
-        }
-    });
-    return {
-        stop: () => {
-            performanceSubscription.unsubscribe();
-        },
-    };
+	if (!isLayoutShiftSupported()) return { stop: _kubesense_kubesense_browser_core.noop };
+	let maxClsValue = 0;
+	let biggestShift;
+	callback({ value: 0 });
+	const slidingWindow = slidingSessionWindow();
+	const performanceSubscription = require_performanceObservable.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: (0, _kubesense_kubesense_js_core_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: (0, _kubesense_kubesense_browser_core.round)(maxClsValue, 4),
+					targetSelector: target && require_getSelectorFromElement.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 && (0, htmlDomUtils_1.isElementNode)(source.node)) {
-            const currentImpactedArea = (0, getClsAttributionImpactedArea_1.getClsAttributionImpactedArea)(source);
-            if (!topImpactedSource || (0, getClsAttributionImpactedArea_1.getClsAttributionImpactedArea)(topImpactedSource) < currentImpactedArea) {
-                topImpactedSource = source;
-            }
-        }
-    }
-    return topImpactedSource;
+	let topImpactedSource;
+	for (const source of sources) if (source.node && require_htmlDomUtils.isElementNode(source.node)) {
+		const currentImpactedArea = require_getClsAttributionImpactedArea.getClsAttributionImpactedArea(source);
+		if (!topImpactedSource || require_getClsAttributionImpactedArea.getClsAttributionImpactedArea(topImpactedSource) < currentImpactedArea) topImpactedSource = source;
+	}
+	return topImpactedSource;
 }
 function asRumRect({ x, y, width, height }) {
-    return { x, y, width, height };
+	return {
+		x,
+		y,
+		width,
+		height
+	};
 }
-exports.MAX_WINDOW_DURATION = 5 * kubesense_browser_core_1.ONE_SECOND;
-const MAX_UPDATE_GAP = kubesense_browser_core_1.ONE_SECOND;
+const MAX_WINDOW_DURATION = 5 * _kubesense_kubesense_js_core_time.ONE_SECOND;
+const MAX_UPDATE_GAP = _kubesense_kubesense_js_core_time.ONE_SECOND;
 function slidingSessionWindow() {
-    let cumulatedValue = 0;
-    let startTime;
-    let endTime;
-    let maxValue = 0;
-    return {
-        update: (entry) => {
-            const shouldCreateNewWindow = startTime === undefined ||
-                entry.startTime - endTime >= MAX_UPDATE_GAP ||
-                entry.startTime - startTime >= exports.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,
-            };
-        },
-    };
+	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.
- */
+* Check whether `layout-shift` is supported by the browser.
+*/
 function isLayoutShiftSupported() {
-    return (0, performanceObservable_1.supportPerformanceTimingEvent)(performanceObservable_1.RumPerformanceEntryType.LAYOUT_SHIFT) && 'WeakRef' in window;
+	return require_performanceObservable.supportPerformanceTimingEvent("layout-shift") && "WeakRef" in window;
 }
+//#endregion
+exports.MAX_WINDOW_DURATION = MAX_WINDOW_DURATION;
+exports.isLayoutShiftSupported = isLayoutShiftSupported;
+exports.trackCumulativeLayoutShift = trackCumulativeLayoutShift;
+
 //# sourceMappingURL=trackCumulativeLayoutShift.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"trackCumulativeLayoutShift.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackCumulativeLayoutShift.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"trackCumulativeLayoutShift.js","names":["noop","createPerformanceObservable","elapsed","round","getSelectorFromElement","isElementNode","getClsAttributionImpactedArea","ONE_SECOND","supportPerformanceTimingEvent"],"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,MAAMA,kCAAAA,KACR;CAGF,IAAI,cAAc;CAClB,IAAI;CAGJ,SAAS,EACP,OAAO,EACT,CAAC;CAED,MAAM,gBAAgB,qBAAqB;CAC3C,MAAM,0BAA0BC,8BAAAA,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,OAAA,GAAMC,kCAAAA,QAAAA,CAAQ,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,QAAA,GAAOC,kCAAAA,MAAAA,CAAM,aAAa,CAAC;KAC3B,gBAAgB,UAAUC,+BAAAA,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,QAAQC,qBAAAA,cAAc,OAAO,IAAI,GAAG;EAC7C,MAAM,sBAAsBC,sCAAAA,8BAA8B,MAAM;EAChE,IAAI,CAAC,qBAAqBA,sCAAAA,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,IAAIC,kCAAAA;AACvC,MAAM,iBAAiBA,kCAAAA;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,OAAOC,8BAAAA,8BAAAA,cAAkE,KAAK,aAAa;AAC7F"}

package/cjs/domain/view/viewMetrics/trackFirstContentfulPaint.d.ts

@@ -1,8 +1,7 @@
-import type { Duration, RelativeTime } from '@kubesense/kubesense-browser-core';
-import type { RumConfiguration } from '../../configuration';
+import type { RelativeTime, Duration } from '@kubesense/kubesense-js-core/time';
 import type { FirstHidden } from './trackFirstHidden';
 export declare const FCP_MAXIMUM_DELAY: number;
-export declare function trackFirstContentfulPaint(configuration: RumConfiguration, firstHidden: FirstHidden, callback: (fcpTiming: RelativeTime) => void): {
+export declare function trackFirstContentfulPaint(firstHidden: FirstHidden, callback: (fcpTiming: RelativeTime) => void): {
     stop: () => void;
 };
 /**

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

@@ -1,39 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FCP_MAXIMUM_DELAY = void 0;
-exports.trackFirstContentfulPaint = trackFirstContentfulPaint;
-exports.trackRestoredFirstContentfulPaint = trackRestoredFirstContentfulPaint;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
-const performanceObservable_1 = require("../../../browser/performanceObservable");
-// Discard FCP timings above a certain delay to avoid incorrect data
-// It happens in some cases like sleep mode or some browser implementations
-exports.FCP_MAXIMUM_DELAY = 10 * kubesense_browser_core_1.ONE_MINUTE;
-function trackFirstContentfulPaint(configuration, firstHidden, callback) {
-    const performanceSubscription = (0, performanceObservable_1.createPerformanceObservable)(configuration, {
-        type: performanceObservable_1.RumPerformanceEntryType.PAINT,
-        buffered: true,
-    }).subscribe((entries) => {
-        const fcpEntry = entries.find((entry) => entry.name === 'first-contentful-paint' &&
-            entry.startTime < firstHidden.timeStamp &&
-            entry.startTime < exports.FCP_MAXIMUM_DELAY);
-        if (fcpEntry) {
-            callback(fcpEntry.startTime);
-        }
-    });
-    return {
-        stop: performanceSubscription.unsubscribe,
-    };
+const require_performanceObservable = require("../../../browser/performanceObservable.js");
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+//#region src/domain/view/viewMetrics/trackFirstContentfulPaint.ts
+const FCP_MAXIMUM_DELAY = 10 * _kubesense_kubesense_js_core_time.ONE_MINUTE;
+function trackFirstContentfulPaint(firstHidden, callback) {
+	return { stop: require_performanceObservable.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.
- */
+* 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((0, kubesense_browser_core_1.elapsed)(viewStartRelative, (0, kubesense_browser_core_1.relativeNow)()));
-        });
-    });
+	requestAnimationFrame(() => {
+		requestAnimationFrame(() => {
+			callback((0, _kubesense_kubesense_js_core_time.elapsed)(viewStartRelative, (0, _kubesense_kubesense_js_core_time.relativeNow)()));
+		});
+	});
 }
+//#endregion
+exports.FCP_MAXIMUM_DELAY = FCP_MAXIMUM_DELAY;
+exports.trackFirstContentfulPaint = trackFirstContentfulPaint;
+exports.trackRestoredFirstContentfulPaint = trackRestoredFirstContentfulPaint;
+
 //# sourceMappingURL=trackFirstContentfulPaint.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"trackFirstContentfulPaint.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackFirstContentfulPaint.ts"],"names":[],"mappings":";;;AAWA,8DAsBC;AAOD,8EAMC;AA7CD,8EAAoF;AAEpF,kFAA6G;AAI7G,oEAAoE;AACpE,2EAA2E;AAC9D,QAAA,iBAAiB,GAAG,EAAE,GAAG,mCAAU,CAAA;AAEhD,SAAgB,yBAAyB,CACvC,aAA+B,EAC/B,WAAwB,EACxB,QAA2C;IAE3C,MAAM,uBAAuB,GAAG,IAAA,mDAA2B,EAAC,aAAa,EAAE;QACzE,IAAI,EAAE,+CAAuB,CAAC,KAAK;QACnC,QAAQ,EAAE,IAAI;KACf,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE;QACvB,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAC3B,CAAC,KAAK,EAAsC,EAAE,CAC5C,KAAK,CAAC,IAAI,KAAK,wBAAwB;YACvC,KAAK,CAAC,SAAS,GAAG,WAAW,CAAC,SAAS;YACvC,KAAK,CAAC,SAAS,GAAG,yBAAiB,CACtC,CAAA;QACD,IAAI,QAAQ,EAAE,CAAC;YACb,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAA;QAC9B,CAAC;IACH,CAAC,CAAC,CAAA;IACF,OAAO;QACL,IAAI,EAAE,uBAAuB,CAAC,WAAW;KAC1C,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAgB,iCAAiC,CAAC,iBAA+B,EAAE,QAAiC;IAClH,qBAAqB,CAAC,GAAG,EAAE;QACzB,qBAAqB,CAAC,GAAG,EAAE;YACzB,QAAQ,CAAC,IAAA,gCAAO,EAAC,iBAAiB,EAAE,IAAA,oCAAW,GAAE,CAAC,CAAC,CAAA;QACrD,CAAC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;AACJ,CAAC"}
+{"version":3,"file":"trackFirstContentfulPaint.js","names":["ONE_MINUTE","createPerformanceObservable","elapsed","relativeNow"],"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,KAAKA,kCAAAA;AAEtC,SAAgB,0BAA0B,aAA0B,UAA6C;CAe/G,OAAO,EACL,MAf8BC,8BAAAA,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,UAAA,GAASC,kCAAAA,QAAAA,CAAQ,oBAAA,GAAmBC,kCAAAA,YAAAA,CAAY,CAAC,CAAC;EACpD,CAAC;CACH,CAAC;AACH"}

package/cjs/domain/view/viewMetrics/trackFirstHidden.d.ts

@@ -1,10 +1,9 @@
-import type { ClocksState, RelativeTime } from '@kubesense/kubesense-browser-core';
-import type { RumConfiguration } from '../../configuration';
+import type { ClocksState, RelativeTime } from '@kubesense/kubesense-js-core/time';
 export type FirstHidden = ReturnType<typeof trackFirstHidden>;
 export interface Options {
     viewStart: ClocksState;
 }
-export declare function trackFirstHidden(configuration: RumConfiguration, viewStart: ClocksState, eventTarget?: Window): {
+export declare function trackFirstHidden(viewStart: ClocksState, eventTarget?: Window): {
     readonly timeStamp: RelativeTime;
     stop: () => void;
 };