@kubesense/kubesense-browser-rum-core 1.0.0

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

@@ -0,0 +1,25 @@
+import type { Duration, RelativeTime } from '@kubesense/kubesense-browser-core';
+import { ViewLoadingType } from '../../../rawRumEvent.types';
+import type { RumConfiguration } from '../../configuration';
+export declare const MAX_INP_VALUE: Duration;
+export interface InteractionToNextPaint {
+    value: Duration;
+    targetSelector?: string;
+    time?: Duration;
+}
+/**
+ * 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
+ */
+export declare function trackInteractionToNextPaint(configuration: RumConfiguration, viewStart: RelativeTime, viewLoadingType: ViewLoadingType): {
+    getInteractionToNextPaint: () => InteractionToNextPaint | undefined;
+    setViewEnd: (viewEndTime: RelativeTime) => void;
+    stop: () => void;
+};
+export declare function trackViewInteractionCount(viewLoadingType: ViewLoadingType): {
+    getViewInteractionCount: () => number;
+    stopViewInteractionCount: () => void;
+};
+export declare function isInteractionToNextPaintSupported(): boolean;

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

@@ -0,0 +1,155 @@
+"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 MAX_INTERACTION_ENTRIES = 10;
+// Arbitrary value to cap INP outliers
+exports.MAX_INP_VALUE = (1 * kubesense_browser_core_1.ONE_MINUTE);
+/**
+ * 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();
+        },
+    };
+}
+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];
+        },
+    };
+}
+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() };
+        },
+    };
+}
+function isInteractionToNextPaintSupported() {
+    return ((0, performanceObservable_1.supportPerformanceTimingEvent)(performanceObservable_1.RumPerformanceEntryType.EVENT) &&
+        window.PerformanceEventTiming &&
+        'interactionId' in PerformanceEventTiming.prototype);
+}
+//# sourceMappingURL=trackInteractionToNextPaint.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trackInteractionToNextPaint.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackInteractionToNextPaint.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,18 @@
+import type { RelativeTime } from '@kubesense/kubesense-browser-core';
+import type { RumConfiguration } from '../../configuration';
+import type { FirstHidden } from './trackFirstHidden';
+export declare const LCP_MAXIMUM_DELAY: number;
+export interface LargestContentfulPaint {
+    value: RelativeTime;
+    targetSelector?: string;
+    resourceUrl?: string;
+}
+/**
+ * Track the largest contentful paint (LCP) occurring during the initial View.  This can yield
+ * multiple values, only the most recent one should be used.
+ * Documentation: https://web.dev/lcp/
+ * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/onLCP.ts
+ */
+export declare function trackLargestContentfulPaint(configuration: RumConfiguration, firstHidden: FirstHidden, eventTarget: Window, callback: (largestContentfulPaint: LargestContentfulPaint) => void): {
+    stop: () => void;
+};

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LCP_MAXIMUM_DELAY = void 0;
+exports.trackLargestContentfulPaint = trackLargestContentfulPaint;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+const performanceObservable_1 = require("../../../browser/performanceObservable");
+const getSelectorFromElement_1 = require("../../getSelectorFromElement");
+// Discard LCP timings above a certain delay to avoid incorrect data
+// It happens in some cases like sleep mode or some browser implementations
+exports.LCP_MAXIMUM_DELAY = 10 * kubesense_browser_core_1.ONE_MINUTE;
+/**
+ * Track the largest contentful paint (LCP) occurring during the initial View.  This can yield
+ * multiple values, only the most recent one should be used.
+ * Documentation: https://web.dev/lcp/
+ * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/onLCP.ts
+ */
+function trackLargestContentfulPaint(configuration, firstHidden, eventTarget, callback) {
+    // Ignore entries that come after the first user interaction. According to the documentation, the
+    // browser should not send largest-contentful-paint entries after a user interact with the page,
+    // but the web-vitals reference implementation uses this as a safeguard.
+    let firstInteractionTimestamp = Infinity;
+    const { stop: stopEventListener } = (0, kubesense_browser_core_1.addEventListeners)(configuration, eventTarget, ["pointerdown" /* DOM_EVENT.POINTER_DOWN */, "keydown" /* DOM_EVENT.KEY_DOWN */], (event) => {
+        firstInteractionTimestamp = event.timeStamp;
+    }, { capture: true, once: true });
+    let biggestLcpSize = 0;
+    const performanceLcpSubscription = (0, performanceObservable_1.createPerformanceObservable)(configuration, {
+        type: performanceObservable_1.RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT,
+        buffered: true,
+    }).subscribe((entries) => {
+        const lcpEntry = (0, kubesense_browser_core_1.findLast)(entries, (entry) => entry.entryType === performanceObservable_1.RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT &&
+            entry.startTime < firstInteractionTimestamp &&
+            entry.startTime < firstHidden.timeStamp &&
+            entry.startTime < exports.LCP_MAXIMUM_DELAY &&
+            // Ensure to get the LCP entry with the biggest size, see
+            // https://bugs.chromium.org/p/chromium/issues/detail?id=1516655
+            entry.size > biggestLcpSize);
+        if (lcpEntry) {
+            let lcpTargetSelector;
+            if (lcpEntry.element) {
+                lcpTargetSelector = (0, getSelectorFromElement_1.getSelectorFromElement)(lcpEntry.element, configuration.actionNameAttribute);
+            }
+            callback({
+                value: lcpEntry.startTime,
+                targetSelector: lcpTargetSelector,
+                resourceUrl: computeLcpEntryUrl(lcpEntry),
+            });
+            biggestLcpSize = lcpEntry.size;
+        }
+    });
+    return {
+        stop: () => {
+            stopEventListener();
+            performanceLcpSubscription.unsubscribe();
+        },
+    };
+}
+// The property url report an empty string if the value is not available, we shouldn't report it in this case.
+function computeLcpEntryUrl(entry) {
+    return entry.url === '' ? undefined : entry.url;
+}
+//# sourceMappingURL=trackLargestContentfulPaint.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trackLargestContentfulPaint.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackLargestContentfulPaint.ts"],"names":[],"mappings":";;;AAwBA,kEAyDC;AAhFD,8EAAsG;AAEtG,kFAA6G;AAE7G,yEAAqE;AAGrE,oEAAoE;AACpE,2EAA2E;AAC9D,QAAA,iBAAiB,GAAG,EAAE,GAAG,mCAAU,CAAA;AAQhD;;;;;GAKG;AACH,SAAgB,2BAA2B,CACzC,aAA+B,EAC/B,WAAwB,EACxB,WAAmB,EACnB,QAAkE;IAElE,iGAAiG;IACjG,gGAAgG;IAChG,wEAAwE;IACxE,IAAI,yBAAyB,GAAG,QAAQ,CAAA;IACxC,MAAM,EAAE,IAAI,EAAE,iBAAiB,EAAE,GAAG,IAAA,0CAAiB,EACnD,aAAa,EACb,WAAW,EACX,gFAA4C,EAC5C,CAAC,KAAK,EAAE,EAAE;QACR,yBAAyB,GAAG,KAAK,CAAC,SAAS,CAAA;IAC7C,CAAC,EACD,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAC9B,CAAA;IAED,IAAI,cAAc,GAAG,CAAC,CAAA;IACtB,MAAM,0BAA0B,GAAG,IAAA,mDAA2B,EAAC,aAAa,EAAE;QAC5E,IAAI,EAAE,+CAAuB,CAAC,wBAAwB;QACtD,QAAQ,EAAE,IAAI;KACf,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE;QACvB,MAAM,QAAQ,GAAG,IAAA,iCAAQ,EACvB,OAAO,EACP,CAAC,KAAK,EAA4C,EAAE,CAClD,KAAK,CAAC,SAAS,KAAK,+CAAuB,CAAC,wBAAwB;YACpE,KAAK,CAAC,SAAS,GAAG,yBAAyB;YAC3C,KAAK,CAAC,SAAS,GAAG,WAAW,CAAC,SAAS;YACvC,KAAK,CAAC,SAAS,GAAG,yBAAiB;YACnC,yDAAyD;YACzD,gEAAgE;YAChE,KAAK,CAAC,IAAI,GAAG,cAAc,CAC9B,CAAA;QACD,IAAI,QAAQ,EAAE,CAAC;YACb,IAAI,iBAAiB,CAAA;YACrB,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;gBACrB,iBAAiB,GAAG,IAAA,+CAAsB,EAAC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,mBAAmB,CAAC,CAAA;YACjG,CAAC;YAED,QAAQ,CAAC;gBACP,KAAK,EAAE,QAAQ,CAAC,SAAS;gBACzB,cAAc,EAAE,iBAAiB;gBACjC,WAAW,EAAE,kBAAkB,CAAC,QAAQ,CAAC;aAC1C,CAAC,CAAA;YACF,cAAc,GAAG,QAAQ,CAAC,IAAI,CAAA;QAChC,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,OAAO;QACL,IAAI,EAAE,GAAG,EAAE;YACT,iBAAiB,EAAE,CAAA;YACnB,0BAA0B,CAAC,WAAW,EAAE,CAAA;QAC1C,CAAC;KACF,CAAA;AACH,CAAC;AAED,8GAA8G;AAC9G,SAAS,kBAAkB,CAAC,KAAsC;IAChE,OAAO,KAAK,CAAC,GAAG,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAA;AACjD,CAAC"}

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

@@ -0,0 +1,14 @@
+import type { ClocksState, Duration, Observable } from '@kubesense/kubesense-browser-core';
+import type { RumConfiguration } from '../../configuration';
+import type { LifeCycle } from '../../lifeCycle';
+import { ViewLoadingType } from '../../../rawRumEvent.types';
+import type { RumMutationRecord } from '../../../browser/domMutationObservable';
+/**
+ * For non-initial views (such as route changes or BFCache restores), the regular load event does not fire
+ * In these cases, trackLoadingTime can only emit a loadingTime  if waitPageActivityEnd detects some post-restore activity.
+ * If nothing happens after the view starts,no candidate is recorded and loadingTime stays undefined.
+ */
+export declare function trackLoadingTime(lifeCycle: LifeCycle, domMutationObservable: Observable<RumMutationRecord[]>, windowOpenObservable: Observable<void>, configuration: RumConfiguration, loadType: ViewLoadingType, viewStart: ClocksState, callback: (loadingTime: Duration) => void): {
+    stop: () => void;
+    setLoadEvent: (loadEvent: Duration) => void;
+};

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackLoadingTime = trackLoadingTime;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+const waitPageActivityEnd_1 = require("../../waitPageActivityEnd");
+const rawRumEvent_types_1 = require("../../../rawRumEvent.types");
+const trackFirstHidden_1 = require("./trackFirstHidden");
+/**
+ * For non-initial views (such as route changes or BFCache restores), the regular load event does not fire
+ * In these cases, trackLoadingTime can only emit a loadingTime  if waitPageActivityEnd detects some post-restore activity.
+ * If nothing happens after the view starts,no candidate is recorded and loadingTime stays undefined.
+ */
+function trackLoadingTime(lifeCycle, domMutationObservable, windowOpenObservable, configuration, loadType, viewStart, callback) {
+    let isWaitingForLoadEvent = loadType === rawRumEvent_types_1.ViewLoadingType.INITIAL_LOAD;
+    let isWaitingForActivityLoadingTime = true;
+    const loadingTimeCandidates = [];
+    const firstHidden = (0, trackFirstHidden_1.trackFirstHidden)(configuration, viewStart);
+    function invokeCallbackIfAllCandidatesAreReceived() {
+        if (!isWaitingForActivityLoadingTime && !isWaitingForLoadEvent && loadingTimeCandidates.length > 0) {
+            const loadingTime = Math.max(...loadingTimeCandidates);
+            // firstHidden is a relative time from time origin, so we use the relative start time of the view to compare with the loading time
+            if (loadingTime < firstHidden.timeStamp - viewStart.relative) {
+                callback(loadingTime);
+            }
+        }
+    }
+    const { stop } = (0, waitPageActivityEnd_1.waitPageActivityEnd)(lifeCycle, domMutationObservable, windowOpenObservable, configuration, (event) => {
+        if (isWaitingForActivityLoadingTime) {
+            isWaitingForActivityLoadingTime = false;
+            if (event.hadActivity) {
+                loadingTimeCandidates.push((0, kubesense_browser_core_1.elapsed)(viewStart.timeStamp, event.end));
+            }
+            invokeCallbackIfAllCandidatesAreReceived();
+        }
+    });
+    return {
+        stop: () => {
+            stop();
+            firstHidden.stop();
+        },
+        setLoadEvent: (loadEvent) => {
+            if (isWaitingForLoadEvent) {
+                isWaitingForLoadEvent = false;
+                loadingTimeCandidates.push(loadEvent);
+                invokeCallbackIfAllCandidatesAreReceived();
+            }
+        },
+    };
+}
+//# sourceMappingURL=trackLoadingTime.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trackLoadingTime.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackLoadingTime.ts"],"names":[],"mappings":";;AAeA,4CAqDC;AAnED,8EAA2D;AAC3D,mEAA+D;AAG/D,kEAA4D;AAE5D,yDAAqD;AAErD;;;;GAIG;AAEH,SAAgB,gBAAgB,CAC9B,SAAoB,EACpB,qBAAsD,EACtD,oBAAsC,EACtC,aAA+B,EAC/B,QAAyB,EACzB,SAAsB,EACtB,QAAyC;IAEzC,IAAI,qBAAqB,GAAG,QAAQ,KAAK,mCAAe,CAAC,YAAY,CAAA;IACrE,IAAI,+BAA+B,GAAG,IAAI,CAAA;IAC1C,MAAM,qBAAqB,GAAe,EAAE,CAAA;IAC5C,MAAM,WAAW,GAAG,IAAA,mCAAgB,EAAC,aAAa,EAAE,SAAS,CAAC,CAAA;IAE9D,SAAS,wCAAwC;QAC/C,IAAI,CAAC,+BAA+B,IAAI,CAAC,qBAAqB,IAAI,qBAAqB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACnG,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,qBAAqB,CAAC,CAAA;YACtD,kIAAkI;YAClI,IAAI,WAAW,GAAG,WAAW,CAAC,SAAS,GAAG,SAAS,CAAC,QAAQ,EAAE,CAAC;gBAC7D,QAAQ,CAAC,WAAuB,CAAC,CAAA;YACnC,CAAC;QACH,CAAC;IACH,CAAC;IAED,MAAM,EAAE,IAAI,EAAE,GAAG,IAAA,yCAAmB,EAClC,SAAS,EACT,qBAAqB,EACrB,oBAAoB,EACpB,aAAa,EACb,CAAC,KAAK,EAAE,EAAE;QACR,IAAI,+BAA+B,EAAE,CAAC;YACpC,+BAA+B,GAAG,KAAK,CAAA;YACvC,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;gBACtB,qBAAqB,CAAC,IAAI,CAAC,IAAA,gCAAO,EAAC,SAAS,CAAC,SAAS,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAA;YACrE,CAAC;YACD,wCAAwC,EAAE,CAAA;QAC5C,CAAC;IACH,CAAC,CACF,CAAA;IAED,OAAO;QACL,IAAI,EAAE,GAAG,EAAE;YACT,IAAI,EAAE,CAAA;YACN,WAAW,CAAC,IAAI,EAAE,CAAA;QACpB,CAAC;QACD,YAAY,EAAE,CAAC,SAAmB,EAAE,EAAE;YACpC,IAAI,qBAAqB,EAAE,CAAC;gBAC1B,qBAAqB,GAAG,KAAK,CAAA;gBAC7B,qBAAqB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;gBACrC,wCAAwC,EAAE,CAAA;YAC5C,CAAC;QACH,CAAC;KACF,CAAA;AACH,CAAC"}

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

@@ -0,0 +1,14 @@
+import type { Duration } from '@kubesense/kubesense-browser-core';
+import type { RumPerformanceNavigationTiming } from '../../../browser/performanceObservable';
+import type { RumConfiguration } from '../../configuration';
+export interface NavigationTimings {
+    domComplete: Duration;
+    domContentLoaded: Duration;
+    domInteractive: Duration;
+    loadEvent: Duration;
+    firstByte: Duration | undefined;
+}
+export type RelevantNavigationTiming = Pick<RumPerformanceNavigationTiming, 'domComplete' | 'domContentLoadedEventEnd' | 'domInteractive' | 'loadEventEnd' | 'responseStart'>;
+export declare function trackNavigationTimings(configuration: RumConfiguration, callback: (timings: NavigationTimings) => void, getNavigationEntryImpl?: () => RelevantNavigationTiming): {
+    stop: () => void;
+};

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackNavigationTimings = trackNavigationTimings;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+const performanceUtils_1 = require("../../../browser/performanceUtils");
+function trackNavigationTimings(configuration, callback, getNavigationEntryImpl = performanceUtils_1.getNavigationEntry) {
+    return waitAfterLoadEvent(configuration, () => {
+        const entry = getNavigationEntryImpl();
+        if (!isIncompleteNavigation(entry)) {
+            callback(processNavigationEntry(entry));
+        }
+    });
+}
+function processNavigationEntry(entry) {
+    return {
+        domComplete: entry.domComplete,
+        domContentLoaded: entry.domContentLoadedEventEnd,
+        domInteractive: entry.domInteractive,
+        loadEvent: entry.loadEventEnd,
+        // In some cases the value reported is negative, zero (meaning unavailable, e.g. cross-origin
+        // without Timing-Allow-Origin), or larger than the current page time. Ignore these cases:
+        // https://github.com/GoogleChrome/web-vitals/issues/137
+        // https://github.com/GoogleChrome/web-vitals/issues/162
+        firstByte: entry.responseStart > 0 && entry.responseStart <= (0, kubesense_browser_core_1.relativeNow)() ? entry.responseStart : undefined,
+    };
+}
+function isIncompleteNavigation(entry) {
+    return entry.loadEventEnd <= 0;
+}
+function waitAfterLoadEvent(configuration, callback) {
+    let timeoutId;
+    const { stop: stopOnReadyState } = (0, kubesense_browser_core_1.runOnReadyState)(configuration, 'complete', () => {
+        // Invoke the callback a bit after the actual load event, so the "loadEventEnd" timing is accurate
+        timeoutId = (0, kubesense_browser_core_1.setTimeout)(() => callback());
+    });
+    return {
+        stop: () => {
+            stopOnReadyState();
+            (0, kubesense_browser_core_1.clearTimeout)(timeoutId);
+        },
+    };
+}
+//# sourceMappingURL=trackNavigationTimings.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trackNavigationTimings.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackNavigationTimings.ts"],"names":[],"mappings":";;AAqBA,wDAYC;AAhCD,8EAA0G;AAG1G,wEAAsE;AAiBtE,SAAgB,sBAAsB,CACpC,aAA+B,EAC/B,QAA8C,EAC9C,yBAAyD,qCAAkB;IAE3E,OAAO,kBAAkB,CAAC,aAAa,EAAE,GAAG,EAAE;QAC5C,MAAM,KAAK,GAAG,sBAAsB,EAAE,CAAA;QAEtC,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,EAAE,CAAC;YACnC,QAAQ,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC,CAAA;QACzC,CAAC;IACH,CAAC,CAAC,CAAA;AACJ,CAAC;AAED,SAAS,sBAAsB,CAAC,KAA+B;IAC7D,OAAO;QACL,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,gBAAgB,EAAE,KAAK,CAAC,wBAAwB;QAChD,cAAc,EAAE,KAAK,CAAC,cAAc;QACpC,SAAS,EAAE,KAAK,CAAC,YAAY;QAC7B,6FAA6F;QAC7F,0FAA0F;QAC1F,wDAAwD;QACxD,wDAAwD;QACxD,SAAS,EAAE,KAAK,CAAC,aAAa,GAAG,CAAC,IAAI,KAAK,CAAC,aAAa,IAAI,IAAA,oCAAW,GAAE,CAAC,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS;KAC7G,CAAA;AACH,CAAC;AAED,SAAS,sBAAsB,CAAC,KAA+B;IAC7D,OAAO,KAAK,CAAC,YAAY,IAAI,CAAC,CAAA;AAChC,CAAC;AAED,SAAS,kBAAkB,CAAC,aAA+B,EAAE,QAAoB;IAC/E,IAAI,SAAgC,CAAA;IACpC,MAAM,EAAE,IAAI,EAAE,gBAAgB,EAAE,GAAG,IAAA,wCAAe,EAAC,aAAa,EAAE,UAAU,EAAE,GAAG,EAAE;QACjF,kGAAkG;QAClG,SAAS,GAAG,IAAA,mCAAU,EAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAA;IAC1C,CAAC,CAAC,CAAA;IACF,OAAO;QACL,IAAI,EAAE,GAAG,EAAE;YACT,gBAAgB,EAAE,CAAA;YAClB,IAAA,qCAAY,EAAC,SAAS,CAAC,CAAA;QACzB,CAAC;KACF,CAAA;AACH,CAAC"}

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

@@ -0,0 +1,25 @@
+import type { ClocksState, Duration } from '@kubesense/kubesense-browser-core';
+import { Observable } from '@kubesense/kubesense-browser-core';
+import type { RumConfiguration } from '../../configuration';
+/** Arbitrary scroll throttle duration */
+export declare const THROTTLE_SCROLL_DURATION = 1000;
+export interface ScrollMetrics {
+    maxDepth: number;
+    maxScrollHeight: number;
+    maxDepthScrollTop: number;
+    maxScrollHeightTime: Duration;
+}
+export declare function trackScrollMetrics(configuration: RumConfiguration, viewStart: ClocksState, callback: (scrollMetrics: ScrollMetrics) => void, scrollValues?: Observable<ScrollValues>): {
+    stop: () => void;
+};
+export interface ScrollValues {
+    scrollDepth: number;
+    scrollTop: number;
+    scrollHeight: number;
+}
+export declare function computeScrollValues(): {
+    scrollHeight: number;
+    scrollDepth: number;
+    scrollTop: number;
+};
+export declare function createScrollValuesObservable(configuration: RumConfiguration, throttleDuration?: number): Observable<ScrollValues>;

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.THROTTLE_SCROLL_DURATION = void 0;
+exports.trackScrollMetrics = trackScrollMetrics;
+exports.computeScrollValues = computeScrollValues;
+exports.createScrollValuesObservable = createScrollValuesObservable;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+const scroll_1 = require("../../../browser/scroll");
+const viewportObservable_1 = require("../../../browser/viewportObservable");
+/** Arbitrary scroll throttle duration */
+exports.THROTTLE_SCROLL_DURATION = kubesense_browser_core_1.ONE_SECOND;
+function trackScrollMetrics(configuration, viewStart, callback, scrollValues = createScrollValuesObservable(configuration)) {
+    let maxScrollDepth = 0;
+    let maxScrollHeight = 0;
+    let maxScrollHeightTime = 0;
+    const subscription = scrollValues.subscribe(({ scrollDepth, scrollTop, scrollHeight }) => {
+        let shouldUpdate = false;
+        if (scrollDepth > maxScrollDepth) {
+            maxScrollDepth = scrollDepth;
+            shouldUpdate = true;
+        }
+        if (scrollHeight > maxScrollHeight) {
+            maxScrollHeight = scrollHeight;
+            const now = (0, kubesense_browser_core_1.relativeNow)();
+            maxScrollHeightTime = (0, kubesense_browser_core_1.elapsed)(viewStart.relative, now);
+            shouldUpdate = true;
+        }
+        if (shouldUpdate) {
+            callback({
+                maxDepth: Math.min(maxScrollDepth, maxScrollHeight),
+                maxDepthScrollTop: scrollTop,
+                maxScrollHeight,
+                maxScrollHeightTime,
+            });
+        }
+    });
+    return {
+        stop: () => subscription.unsubscribe(),
+    };
+}
+function computeScrollValues() {
+    const scrollTop = (0, scroll_1.getScrollY)();
+    const { height } = (0, viewportObservable_1.getViewportDimension)();
+    const scrollHeight = Math.round((document.scrollingElement || document.documentElement).scrollHeight);
+    const scrollDepth = Math.round(height + scrollTop);
+    return {
+        scrollHeight,
+        scrollDepth,
+        scrollTop,
+    };
+}
+function createScrollValuesObservable(configuration, throttleDuration = exports.THROTTLE_SCROLL_DURATION) {
+    return new kubesense_browser_core_1.Observable((observable) => {
+        function notify() {
+            observable.notify(computeScrollValues());
+        }
+        if (window.ResizeObserver) {
+            const throttledNotify = (0, kubesense_browser_core_1.throttle)(notify, throttleDuration, {
+                leading: false,
+                trailing: true,
+            });
+            const observerTarget = document.scrollingElement || document.documentElement;
+            const resizeObserver = new ResizeObserver((0, kubesense_browser_core_1.monitor)(throttledNotify.throttled));
+            if (observerTarget) {
+                resizeObserver.observe(observerTarget);
+            }
+            const eventListener = (0, kubesense_browser_core_1.addEventListener)(configuration, window, "scroll" /* DOM_EVENT.SCROLL */, throttledNotify.throttled, {
+                passive: true,
+            });
+            return () => {
+                throttledNotify.cancel();
+                resizeObserver.disconnect();
+                eventListener.stop();
+            };
+        }
+    });
+}
+//# sourceMappingURL=trackScrollMetrics.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trackScrollMetrics.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackScrollMetrics.ts"],"names":[],"mappings":";;;AAyBA,gDAsCC;AAQD,kDAcC;AAED,oEA+BC;AArHD,8EAS0C;AAE1C,oDAAoD;AACpD,4EAA0E;AAE1E,yCAAyC;AAC5B,QAAA,wBAAwB,GAAG,mCAAU,CAAA;AASlD,SAAgB,kBAAkB,CAChC,aAA+B,EAC/B,SAAsB,EACtB,QAAgD,EAChD,YAAY,GAAG,4BAA4B,CAAC,aAAa,CAAC;IAE1D,IAAI,cAAc,GAAG,CAAC,CAAA;IACtB,IAAI,eAAe,GAAG,CAAC,CAAA;IACvB,IAAI,mBAAmB,GAAG,CAAa,CAAA;IAEvC,MAAM,YAAY,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC,EAAE,WAAW,EAAE,SAAS,EAAE,YAAY,EAAE,EAAE,EAAE;QACvF,IAAI,YAAY,GAAG,KAAK,CAAA;QAExB,IAAI,WAAW,GAAG,cAAc,EAAE,CAAC;YACjC,cAAc,GAAG,WAAW,CAAA;YAC5B,YAAY,GAAG,IAAI,CAAA;QACrB,CAAC;QAED,IAAI,YAAY,GAAG,eAAe,EAAE,CAAC;YACnC,eAAe,GAAG,YAAY,CAAA;YAC9B,MAAM,GAAG,GAAG,IAAA,oCAAW,GAAE,CAAA;YACzB,mBAAmB,GAAG,IAAA,gCAAO,EAAC,SAAS,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAA;YACtD,YAAY,GAAG,IAAI,CAAA;QACrB,CAAC;QAED,IAAI,YAAY,EAAE,CAAC;YACjB,QAAQ,CAAC;gBACP,QAAQ,EAAE,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,eAAe,CAAC;gBACnD,iBAAiB,EAAE,SAAS;gBAC5B,eAAe;gBACf,mBAAmB;aACpB,CAAC,CAAA;QACJ,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,OAAO;QACL,IAAI,EAAE,GAAG,EAAE,CAAC,YAAY,CAAC,WAAW,EAAE;KACvC,CAAA;AACH,CAAC;AAQD,SAAgB,mBAAmB;IACjC,MAAM,SAAS,GAAG,IAAA,mBAAU,GAAE,CAAA;IAE9B,MAAM,EAAE,MAAM,EAAE,GAAG,IAAA,yCAAoB,GAAE,CAAA;IAEzC,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,gBAAgB,IAAI,QAAQ,CAAC,eAAe,CAAC,CAAC,YAAY,CAAC,CAAA;IAErG,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;IAElD,OAAO;QACL,YAAY;QACZ,WAAW;QACX,SAAS;KACV,CAAA;AACH,CAAC;AAED,SAAgB,4BAA4B,CAC1C,aAA+B,EAC/B,gBAAgB,GAAG,gCAAwB;IAE3C,OAAO,IAAI,mCAAU,CAAe,CAAC,UAAU,EAAE,EAAE;QACjD,SAAS,MAAM;YACb,UAAU,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAC,CAAA;QAC1C,CAAC;QAED,IAAI,MAAM,CAAC,cAAc,EAAE,CAAC;YAC1B,MAAM,eAAe,GAAG,IAAA,iCAAQ,EAAC,MAAM,EAAE,gBAAgB,EAAE;gBACzD,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE,IAAI;aACf,CAAC,CAAA;YAEF,MAAM,cAAc,GAAG,QAAQ,CAAC,gBAAgB,IAAI,QAAQ,CAAC,eAAe,CAAA;YAC5E,MAAM,cAAc,GAAG,IAAI,cAAc,CAAC,IAAA,gCAAO,EAAC,eAAe,CAAC,SAAS,CAAC,CAAC,CAAA;YAC7E,IAAI,cAAc,EAAE,CAAC;gBACnB,cAAc,CAAC,OAAO,CAAC,cAAc,CAAC,CAAA;YACxC,CAAC;YACD,MAAM,aAAa,GAAG,IAAA,yCAAgB,EAAC,aAAa,EAAE,MAAM,mCAAoB,eAAe,CAAC,SAAS,EAAE;gBACzG,OAAO,EAAE,IAAI;aACd,CAAC,CAAA;YAEF,OAAO,GAAG,EAAE;gBACV,eAAe,CAAC,MAAM,EAAE,CAAA;gBACxB,cAAc,CAAC,UAAU,EAAE,CAAA;gBAC3B,aAAa,CAAC,IAAI,EAAE,CAAA;YACtB,CAAC,CAAA;QACH,CAAC;IACH,CAAC,CAAC,CAAA;AACJ,CAAC"}

package/cjs/domain/vital/vitalCollection.d.ts

@@ -0,0 +1,55 @@
+import type { ClocksState, Duration } from '@kubesense/kubesense-browser-core';
+import type { LifeCycle } from '../lifeCycle';
+import { VitalType } from '../../rawRumEvent.types';
+import type { PageStateHistory } from '../contexts/pageStateHistory';
+export interface VitalOptions {
+    context?: any;
+    description?: string;
+}
+export type DurationVitalOptions = VitalOptions;
+export interface FeatureOperationOptions extends VitalOptions {
+    operationKey?: string;
+}
+export type FailureReason = 'error' | 'abandoned' | 'other';
+export interface AddDurationVitalOptions extends DurationVitalOptions {
+    startTime: number;
+    duration: number;
+}
+export interface DurationVitalReference {
+    __kubesense_vital_reference: true;
+}
+export interface DurationVitalStart extends DurationVitalOptions {
+    name: string;
+    startClocks: ClocksState;
+}
+interface BaseVital extends VitalOptions {
+    name: string;
+    startClocks: ClocksState;
+}
+export interface DurationVital extends BaseVital {
+    type: typeof VitalType.DURATION;
+    duration: Duration;
+}
+export interface OperationStepVital extends BaseVital {
+    type: typeof VitalType.OPERATION_STEP;
+    stepType: 'start' | 'end';
+    operationKey?: string;
+    failureReason?: string;
+}
+export interface CustomVitalsState {
+    vitalsByName: Map<string, DurationVitalStart>;
+    vitalsByReference: WeakMap<DurationVitalReference, DurationVitalStart>;
+}
+export declare function createCustomVitalsState(): {
+    vitalsByName: Map<string, DurationVitalStart>;
+    vitalsByReference: WeakMap<DurationVitalReference, DurationVitalStart>;
+};
+export declare function startVitalCollection(lifeCycle: LifeCycle, pageStateHistory: PageStateHistory, customVitalsState: CustomVitalsState): {
+    addOperationStepVital: (name: string, stepType: "start" | "end", options?: FeatureOperationOptions, failureReason?: FailureReason) => void;
+    addDurationVital: (vital: DurationVital) => void;
+    startDurationVital: (name: string, options?: DurationVitalOptions) => DurationVitalReference;
+    stopDurationVital: (nameOrRef: string | DurationVitalReference, options?: DurationVitalOptions) => void;
+};
+export declare function startDurationVital({ vitalsByName, vitalsByReference }: CustomVitalsState, name: string, options?: DurationVitalOptions): DurationVitalReference;
+export declare function stopDurationVital(stopCallback: (vital: DurationVital) => void, { vitalsByName, vitalsByReference }: CustomVitalsState, nameOrRef: string | DurationVitalReference, options?: DurationVitalOptions): void;
+export {};