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

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

@@ -1 +1 @@
-{"version":3,"file":"trackInteractionToNextPaint.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackInteractionToNextPaint.ts"],"names":[],"mappings":";;;AA+BA,kEAsFC;AA8CD,8DAqBC;AAED,8EAMC;AAhMD,8EAA6E;AAE7E,kFAI+C;AAE/C,kEAA4D;AAC5D,yEAAqE;AACrE,gEAA6D;AAC7D,oFAA8E;AAE9E,yEAA8F;AAE9F,0FAA0F;AAC1F,MAAM,uBAAuB,GAAG,EAAE,CAAA;AAClC,sCAAsC;AACzB,QAAA,aAAa,GAAG,CAAC,CAAC,GAAG,mCAAU,CAAa,CAAA;AAOzD;;;;;GAKG;AACH,SAAgB,2BAA2B,CACzC,aAA+B,EAC/B,SAAuB,EACvB,eAAgC;IAEhC,IAAI,CAAC,iCAAiC,EAAE,EAAE,CAAC;QACzC,OAAO;YACL,yBAAyB,EAAE,GAAG,EAAE,CAAC,SAAS;YAC1C,UAAU,EAAE,6BAAI;YAChB,IAAI,EAAE,6BAAI;SACX,CAAA;IACH,CAAC;IAED,MAAM,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,GAAG,yBAAyB,CAAC,eAAe,CAAC,CAAA;IAExG,IAAI,OAAO,GAAG,QAAwB,CAAA;IAEtC,MAAM,mBAAmB,GAAG,wBAAwB,CAAC,uBAAuB,CAAC,CAAA;IAC7E,IAAI,sBAAsB,GAAG,CAAC,CAAa,CAAA;IAC3C,IAAI,oCAAwD,CAAA;IAC5D,IAAI,+BAAqD,CAAA;IAEzD,SAAS,aAAa,CAAC,OAA+D;QACpF,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;YAC5B,IACE,KAAK,CAAC,aAAa;gBACnB,6IAA6I;gBAC7I,KAAK,CAAC,SAAS,IAAI,SAAS;gBAC5B,KAAK,CAAC,SAAS,IAAI,OAAO,EAC1B,CAAC;gBACD,mBAAmB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;YACpC,CAAC;QACH,CAAC;QAED,MAAM,cAAc,GAAG,mBAAmB,CAAC,sBAAsB,EAAE,CAAA;QACnE,IAAI,cAAc,IAAI,cAAc,CAAC,QAAQ,KAAK,sBAAsB,EAAE,CAAC;YACzE,sBAAsB,GAAG,cAAc,CAAC,QAAQ,CAAA;YAChD,+BAA+B,GAAG,IAAA,gCAAO,EAAC,SAAS,EAAE,cAAc,CAAC,SAAS,CAAC,CAAA;YAC9E,oCAAoC,GAAG,IAAA,iDAAsB,EAAC,cAAc,CAAC,SAAS,CAAC,CAAA;YACvF,IAAI,CAAC,oCAAoC,IAAI,cAAc,CAAC,MAAM,IAAI,IAAA,4BAAa,EAAC,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC3G,oCAAoC,GAAG,IAAA,+CAAsB,EAC3D,cAAc,CAAC,MAAM,EACrB,aAAa,CAAC,mBAAmB,CAClC,CAAA;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED,MAAM,sBAAsB,GAAG,IAAA,mDAA2B,EAAC,aAAa,EAAE;QACxE,IAAI,EAAE,+CAAuB,CAAC,WAAW;QACzC,QAAQ,EAAE,IAAI;KACf,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAA;IAE3B,MAAM,iBAAiB,GAAG,IAAA,mDAA2B,EAAC,aAAa,EAAE;QACnE,IAAI,EAAE,+CAAuB,CAAC,KAAK;QACnC,4IAA4I;QAC5I,sHAAsH;QACtH,iBAAiB,EAAE,EAAE;QACrB,QAAQ,EAAE,IAAI;KACf,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAA;IAE3B,OAAO;QACL,yBAAyB,EAAE,GAAuC,EAAE;YAClE,sFAAsF;YACtF,mDAAmD;YACnD,IAAI,sBAAsB,IAAI,CAAC,EAAE,CAAC;gBAChC,OAAO;oBACL,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,sBAAsB,EAAE,qBAAa,CAAa;oBAClE,cAAc,EAAE,oCAAoC;oBACpD,IAAI,EAAE,+BAA+B;iBACtC,CAAA;YACH,CAAC;iBAAM,IAAI,uBAAuB,EAAE,EAAE,CAAC;gBACrC,OAAO;oBACL,KAAK,EAAE,CAAa;iBACrB,CAAA;YACH,CAAC;QACH,CAAC;QACD,UAAU,EAAE,CAAC,WAAyB,EAAE,EAAE;YACxC,OAAO,GAAG,WAAW,CAAA;YACrB,wBAAwB,EAAE,CAAA;QAC5B,CAAC;QACD,IAAI,EAAE,GAAG,EAAE;YACT,iBAAiB,CAAC,WAAW,EAAE,CAAA;YAC/B,sBAAsB,CAAC,WAAW,EAAE,CAAA;QACtC,CAAC;KACF,CAAA;AACH,CAAC;AAED,SAAS,wBAAwB,CAAC,uBAAqC;IACrE,MAAM,mBAAmB,GAA2D,EAAE,CAAA;IAEtF,SAAS,8BAA8B;QACrC,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,uBAAuB,CAAC,CAAA;IAC7F,CAAC;IAED,OAAO;QACL;;;;WAIG;QACH,OAAO,CAAC,KAAsD;YAC5D,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,SAAS,CACpD,CAAC,WAAW,EAAE,EAAE,CAAC,KAAK,CAAC,aAAa,KAAK,WAAW,CAAC,aAAa,CACnE,CAAA;YAED,MAAM,qBAAqB,GAAG,mBAAmB,CAAC,mBAAmB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;YAEjF,IAAI,gBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC;gBAC5B,IAAI,KAAK,CAAC,QAAQ,GAAG,mBAAmB,CAAC,gBAAgB,CAAC,CAAC,QAAQ,EAAE,CAAC;oBACpE,mBAAmB,CAAC,gBAAgB,CAAC,GAAG,KAAK,CAAA;oBAC7C,8BAA8B,EAAE,CAAA;gBAClC,CAAC;YACH,CAAC;iBAAM,IACL,mBAAmB,CAAC,MAAM,GAAG,uBAAuB;gBACpD,KAAK,CAAC,QAAQ,GAAG,qBAAqB,CAAC,QAAQ,EAC/C,CAAC;gBACD,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;gBAC/B,8BAA8B,EAAE,CAAA;YAClC,CAAC;QACH,CAAC;QACD;;;WAGG;QACH,sBAAsB;YACpB,MAAM,gBAAgB,GAAG,IAAI,CAAC,GAAG,CAAC,mBAAmB,CAAC,MAAM,GAAG,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,uBAAuB,EAAE,GAAG,EAAE,CAAC,CAAC,CAAA;YAC7G,OAAO,mBAAmB,CAAC,gBAAgB,CAAC,CAAA;QAC9C,CAAC;KACF,CAAA;AACH,CAAC;AAED,SAAgB,yBAAyB,CAAC,eAAgC;IACxE,IAAA,uDAA4B,GAAE,CAAA;IAC9B,MAAM,wBAAwB,GAAG,eAAe,KAAK,mCAAe,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAA,8CAAmB,GAAE,CAAA;IAC7G,IAAI,KAAK,GAAqE,EAAE,OAAO,EAAE,KAAK,EAAE,CAAA;IAEhG,SAAS,2BAA2B;QAClC,OAAO,IAAA,8CAAmB,GAAE,GAAG,wBAAwB,CAAA;IACzD,CAAC;IAED,OAAO;QACL,uBAAuB,EAAE,GAAG,EAAE;YAC5B,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;gBAClB,OAAO,KAAK,CAAC,gBAAgB,CAAA;YAC/B,CAAC;YAED,OAAO,2BAA2B,EAAE,CAAA;QACtC,CAAC;QACD,wBAAwB,EAAE,GAAG,EAAE;YAC7B,KAAK,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,2BAA2B,EAAE,EAAE,CAAA;QAC5E,CAAC;KACF,CAAA;AACH,CAAC;AAED,SAAgB,iCAAiC;IAC/C,OAAO,CACL,IAAA,qDAA6B,EAAC,+CAAuB,CAAC,KAAK,CAAC;QAC5D,MAAM,CAAC,sBAAsB;QAC7B,eAAe,IAAI,sBAAsB,CAAC,SAAS,CACpD,CAAA;AACH,CAAC"}
+{"version":3,"file":"trackInteractionToNextPaint.js","names":["ONE_MINUTE","noop","createPerformanceObservable","elapsed","getInteractionSelector","isElementNode","getSelectorFromElement","ViewLoadingType","getInteractionCount","supportPerformanceTimingEvent"],"sources":["../../../../src/domain/view/viewMetrics/trackInteractionToNextPaint.ts"],"sourcesContent":["import type { RelativeTime, Duration } from '@kubesense/kubesense-js-core/time'\nimport { ONE_MINUTE, elapsed } from '@kubesense/kubesense-js-core/time'\nimport { noop } from '@kubesense/kubesense-browser-core'\nimport type { RumFirstInputTiming, RumPerformanceEventTiming } from '../../../browser/performanceObservable'\nimport {\n  createPerformanceObservable,\n  RumPerformanceEntryType,\n  supportPerformanceTimingEvent,\n} from '../../../browser/performanceObservable'\nimport { ViewLoadingType } from '../../../rawRumEvent.types'\nimport { getSelectorFromElement } from '../../getSelectorFromElement'\nimport { isElementNode } from '../../../browser/htmlDomUtils'\nimport { getInteractionSelector } from '../../action/interactionSelectorCache'\nimport type { RumConfiguration } from '../../configuration'\nimport { getInteractionCount, initInteractionCountPolyfill } from './interactionCountPolyfill'\n\n// Arbitrary value to prevent unnecessary memory usage on views with lots of interactions.\nconst MAX_INTERACTION_ENTRIES = 10\n// Arbitrary value to cap INP outliers\nexport const MAX_INP_VALUE = (1 * ONE_MINUTE) as Duration\n\n// Event Timing API rounds duration values to the nearest 8 ms\nconst RENDER_TIME_GROUPING_THRESHOLD = 8 as Duration\n\nexport interface InteractionToNextPaint {\n  value: Duration\n  targetSelector?: string\n  time?: Duration\n  subParts?: {\n    inputDelay: Duration\n    processingDuration: Duration\n    presentationDelay: Duration\n  }\n}\ninterface EntriesGroup {\n  startTime: RelativeTime\n  processingStart: RelativeTime\n  processingEnd: RelativeTime\n  // Reference time used for grouping, set once at group creation — anchors the 8ms merge window\n  referenceRenderTime: RelativeTime\n}\n\n/**\n * Track the interaction to next paint (INP).\n * To avoid outliers, return the p98 worst interaction of the view.\n * Documentation: https://web.dev/inp/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/main/src/onINP.ts\n */\nexport function trackInteractionToNextPaint(\n  configuration: RumConfiguration,\n  viewStart: RelativeTime,\n  viewLoadingType: ViewLoadingType\n) {\n  if (!isInteractionToNextPaintSupported()) {\n    return {\n      getInteractionToNextPaint: () => undefined,\n      setViewEnd: noop,\n      stop: noop,\n    }\n  }\n\n  let viewEnd = Infinity as RelativeTime\n  let currentInp:\n    | {\n        duration: Duration\n        startTime: Duration\n        targetSelector?: string\n        subParts?: InteractionToNextPaint['subParts']\n      }\n    | undefined\n\n  const { getViewInteractionCount, stopViewInteractionCount } = trackViewInteractionCount(viewLoadingType)\n  const longestInteractions = trackLongestInteractions(getViewInteractionCount)\n  const subPartsTracker = createSubPartsTracker(longestInteractions)\n  const firstInputSubscription = createPerformanceObservable({\n    type: RumPerformanceEntryType.FIRST_INPUT,\n    buffered: true,\n  }).subscribe(handleEntries)\n  const eventSubscription = createPerformanceObservable({\n    type: RumPerformanceEntryType.EVENT,\n    // durationThreshold only impact PerformanceEventTiming entries used for INP computation which requires a threshold at 40 (default is 104ms)\n    // cf: https://github.com/GoogleChrome/web-vitals/blob/3806160ffbc93c3c4abf210a167b81228172b31c/src/onINP.ts#L202-L210\n    durationThreshold: 40,\n    buffered: true,\n  }).subscribe(handleEntries)\n\n  function handleEntries(entries: Array<RumPerformanceEventTiming | RumFirstInputTiming>) {\n    for (const entry of entries) {\n      if (\n        entry.interactionId &&\n        // Check the entry start time is inside the view bounds because some view interactions can be reported after the view end (if long duration).\n        entry.startTime >= viewStart &&\n        entry.startTime <= viewEnd\n      ) {\n        longestInteractions.process(entry)\n        subPartsTracker.process(entry)\n      }\n    }\n    subPartsTracker.pruneUntracked()\n    const candidate = longestInteractions.estimateP98Interaction()\n    if (candidate) {\n      updateCurrentInp(candidate)\n    }\n  }\n\n  function updateCurrentInp(candidate: RumPerformanceEventTiming | RumFirstInputTiming) {\n    const newStartTime = elapsed(viewStart, candidate.startTime)\n    // startTime catches identity changes when the p98 switches to a different interaction with the same duration,\n    // ensuring targetSelector and subParts always describe the same interaction.\n    if (candidate.duration !== currentInp?.duration || newStartTime !== currentInp.startTime) {\n      let targetSelector = getInteractionSelector(candidate.startTime)\n      if (!targetSelector && candidate.target && isElementNode(candidate.target)) {\n        targetSelector = getSelectorFromElement(candidate.target, configuration.actionNameAttribute)\n      }\n      currentInp = {\n        duration: candidate.duration,\n        startTime: newStartTime,\n        targetSelector,\n      }\n    }\n    // Recomputed on every batch: the group for the p98 interaction may have been updated\n    // with new min/max timing even when the p98 identity (duration, startTime) is unchanged.\n    currentInp.subParts = subPartsTracker.computeSubParts(candidate, sanitizeInpValue(currentInp.duration))\n  }\n\n  return {\n    getInteractionToNextPaint: (): InteractionToNextPaint | undefined => {\n      // If no INP duration where captured because of the performanceObserver 40ms threshold\n      // but the view interaction count > 0 then report 0\n      if (currentInp) {\n        return {\n          value: sanitizeInpValue(currentInp.duration),\n          targetSelector: currentInp.targetSelector,\n          time: currentInp.startTime,\n          subParts: currentInp.subParts,\n        }\n      } else if (getViewInteractionCount()) {\n        return {\n          value: 0 as Duration,\n        }\n      }\n    },\n    setViewEnd: (viewEndTime: RelativeTime) => {\n      viewEnd = viewEndTime\n      stopViewInteractionCount()\n    },\n    stop: () => {\n      eventSubscription.unsubscribe()\n      firstInputSubscription.unsubscribe()\n      subPartsTracker.stop()\n    },\n  }\n}\n\n/**\n * Maintains a bounded list of the slowest interactions seen so far, used to estimate the p98\n * interaction duration without keeping every entry in memory.\n */\nfunction trackLongestInteractions(getViewInteractionCount: () => number) {\n  const longestInteractions: Array<RumPerformanceEventTiming | RumFirstInputTiming> = []\n\n  function sortAndTrimLongestInteractions() {\n    longestInteractions.sort((a, b) => b.duration - a.duration).splice(MAX_INTERACTION_ENTRIES)\n  }\n\n  return {\n    /**\n     * Process the performance entry:\n     * - if its duration is long enough, add the performance entry to the list of worst interactions\n     * - 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\n     */\n    process(entry: RumPerformanceEventTiming | RumFirstInputTiming) {\n      const interactionIndex = longestInteractions.findIndex(\n        (interaction) => entry.interactionId === interaction.interactionId\n      )\n\n      const minLongestInteraction = longestInteractions[longestInteractions.length - 1]\n\n      if (interactionIndex !== -1) {\n        if (entry.duration > longestInteractions[interactionIndex].duration) {\n          longestInteractions[interactionIndex] = entry\n          sortAndTrimLongestInteractions()\n        }\n      } else if (\n        longestInteractions.length < MAX_INTERACTION_ENTRIES ||\n        entry.duration > minLongestInteraction.duration\n      ) {\n        longestInteractions.push(entry)\n        sortAndTrimLongestInteractions()\n      }\n    },\n    /**\n     * Compute the p98 longest interaction.\n     * For better performance the computation is based on 10 longest interactions and the interaction count of the current view.\n     */\n    estimateP98Interaction(): RumPerformanceEventTiming | RumFirstInputTiming | undefined {\n      const interactionIndex = Math.min(longestInteractions.length - 1, Math.floor(getViewInteractionCount() / 50))\n      return longestInteractions[interactionIndex]\n    },\n\n    isTracked(interactionId: number): boolean {\n      return longestInteractions.some((i) => i.interactionId === interactionId)\n    },\n  }\n}\n\n/**\n * Tracks the number of interactions that occurred during the current view. Freezes the count\n * when the view ends so that the p98 estimate remains stable after `setViewEnd` is called.\n */\nexport function trackViewInteractionCount(viewLoadingType: ViewLoadingType) {\n  initInteractionCountPolyfill()\n  const previousInteractionCount = viewLoadingType === ViewLoadingType.INITIAL_LOAD ? 0 : getInteractionCount()\n  let state: { stopped: false } | { stopped: true; interactionCount: number } = { stopped: false }\n\n  function computeViewInteractionCount() {\n    return getInteractionCount() - previousInteractionCount\n  }\n\n  return {\n    getViewInteractionCount: () => {\n      if (state.stopped) {\n        return state.interactionCount\n      }\n\n      return computeViewInteractionCount()\n    },\n    stopViewInteractionCount: () => {\n      state = { stopped: true, interactionCount: computeViewInteractionCount() }\n    },\n  }\n}\n\n/**\n * Groups performance entries by interaction and render time to compute INP subparts\n * (input delay, processing duration, presentation delay). Entries sharing the same\n * interactionId, or whose render time falls within the 8 ms Event Timing rounding window,\n * are merged into a single group so that subparts always sum to the reported INP duration.\n */\nfunction createSubPartsTracker(longestInteractions: ReturnType<typeof trackLongestInteractions>) {\n  const groupsByInteractionId = new Map<number, EntriesGroup>()\n\n  function updateGroupWithEntry(group: EntriesGroup, entry: RumPerformanceEventTiming | RumFirstInputTiming) {\n    group.startTime = Math.min(entry.startTime, group.startTime) as RelativeTime\n    // For each group, we keep the biggest interval possible between processingStart and processingEnd\n    group.processingStart = Math.min(entry.processingStart, group.processingStart) as RelativeTime\n    group.processingEnd = Math.max(entry.processingEnd, group.processingEnd) as RelativeTime\n  }\n\n  return {\n    process(entry: RumPerformanceEventTiming | RumFirstInputTiming): void {\n      if (entry.interactionId === undefined || !entry.processingStart || !entry.processingEnd) {\n        return\n      }\n\n      const renderTime = (entry.startTime + entry.duration) as RelativeTime\n      const existingGroup = groupsByInteractionId.get(entry.interactionId)\n\n      if (existingGroup) {\n        // Update existing group with MIN/MAX values (keep original referenceRenderTime)\n        updateGroupWithEntry(existingGroup, entry)\n        return\n      }\n\n      // Try to find a group within 8ms window to merge with (different interactionId, same frame)\n      for (const [, group] of groupsByInteractionId.entries()) {\n        if (Math.abs(renderTime - group.referenceRenderTime) <= RENDER_TIME_GROUPING_THRESHOLD) {\n          updateGroupWithEntry(group, entry)\n          // Also store under this entry's interactionId for easy lookup\n          groupsByInteractionId.set(entry.interactionId, group)\n          return\n        }\n      }\n\n      // Create new group\n      groupsByInteractionId.set(entry.interactionId, {\n        startTime: entry.startTime,\n        processingStart: entry.processingStart,\n        processingEnd: entry.processingEnd,\n        referenceRenderTime: renderTime,\n      })\n    },\n\n    // Prune after all entries are grouped: groups not in longestInteractions can never affect p98 subparts.\n    // Keeps groupsByInteractionId capped at MAX_INTERACTION_ENTRIES\n    pruneUntracked(): void {\n      for (const [interactionId] of groupsByInteractionId) {\n        if (!longestInteractions.isTracked(interactionId)) {\n          groupsByInteractionId.delete(interactionId)\n        }\n      }\n    },\n\n    computeSubParts(\n      entry: RumPerformanceEventTiming | RumFirstInputTiming,\n      inpDuration: Duration\n    ): InteractionToNextPaint['subParts'] | undefined {\n      if (!entry.processingStart || !entry.processingEnd || entry.interactionId === undefined) {\n        return undefined\n      }\n\n      const group = groupsByInteractionId.get(entry.interactionId)\n      // Shouldn't happen since entries are grouped before p98 calculation.\n      if (!group) {\n        return undefined\n      }\n\n      // Use group.startTime consistently to ensure subparts sum to inpDuration\n      // Math.max prevents nextPaintTime from being before processingStart (Chrome implementation)\n      const nextPaintTime = Math.max(group.startTime + inpDuration, group.processingStart) as RelativeTime\n\n      // Clamp processingEnd to not exceed nextPaintTime\n      const processingEnd = Math.min(group.processingEnd, nextPaintTime) as RelativeTime\n\n      return {\n        inputDelay: elapsed(group.startTime, group.processingStart),\n        processingDuration: elapsed(group.processingStart, processingEnd),\n        presentationDelay: elapsed(processingEnd, nextPaintTime),\n      }\n    },\n\n    stop(): void {\n      groupsByInteractionId.clear()\n    },\n  }\n}\n\nexport function isInteractionToNextPaintSupported() {\n  return (\n    supportPerformanceTimingEvent(RumPerformanceEntryType.EVENT) &&\n    window.PerformanceEventTiming &&\n    'interactionId' in PerformanceEventTiming.prototype\n  )\n}\n\nfunction sanitizeInpValue(inpValue: Duration) {\n  return Math.min(inpValue, MAX_INP_VALUE) as Duration\n}\n"],"mappings":"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"}

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

@@ -1,4 +1,4 @@
-import type { RelativeTime } from '@kubesense/kubesense-browser-core';
+import type { RelativeTime } from '@kubesense/kubesense-js-core/time';
 import type { RumConfiguration } from '../../configuration';
 import type { FirstHidden } from './trackFirstHidden';
 export declare const LCP_MAXIMUM_DELAY: number;
@@ -6,6 +6,11 @@ export interface LargestContentfulPaint {
     value: RelativeTime;
     targetSelector?: string;
     resourceUrl?: string;
+    subParts?: {
+        loadDelay: RelativeTime;
+        loadTime: RelativeTime;
+        renderDelay: RelativeTime;
+    };
 }
 /**
  * Track the largest contentful paint (LCP) occurring during the initial View.  This can yield

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

@@ -1,61 +1,71 @@
-"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;
+const require_performanceObservable = require("../../../browser/performanceObservable.js");
+const require_getSelectorFromElement = require("../../getSelectorFromElement.js");
+const require_performanceUtils = require("../../../browser/performanceUtils.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/trackLargestContentfulPaint.ts
+const LCP_MAXIMUM_DELAY = 10 * _kubesense_kubesense_js_core_time.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
- */
+* 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();
-        },
-    };
+	let firstInteractionTimestamp = Infinity;
+	const { stop: stopEventListener } = (0, _kubesense_kubesense_browser_core.addEventListeners)(eventTarget, [_kubesense_kubesense_browser_core.DOM_EVENT.POINTER_DOWN, _kubesense_kubesense_browser_core.DOM_EVENT.KEY_DOWN], (event) => {
+		firstInteractionTimestamp = event.timeStamp;
+	}, {
+		capture: true,
+		once: true
+	});
+	let biggestLcpSize = 0;
+	const performanceLcpSubscription = require_performanceObservable.createPerformanceObservable({
+		type: "largest-contentful-paint",
+		buffered: true
+	}).subscribe((entries) => {
+		const lcpEntry = (0, _kubesense_kubesense_browser_core.findLast)(entries, (entry) => entry.entryType === "largest-contentful-paint" && entry.startTime < firstInteractionTimestamp && entry.startTime < firstHidden.timeStamp && entry.startTime < LCP_MAXIMUM_DELAY && entry.size > biggestLcpSize);
+		if (lcpEntry) {
+			let lcpTargetSelector;
+			if (lcpEntry.element) lcpTargetSelector = require_getSelectorFromElement.getSelectorFromElement(lcpEntry.element, configuration.actionNameAttribute);
+			const resourceUrl = computeLcpEntryUrl(lcpEntry);
+			const lcpValue = lcpEntry.startTime;
+			const subParts = computeLcpSubParts(resourceUrl, lcpValue);
+			callback({
+				value: lcpValue,
+				targetSelector: lcpTargetSelector,
+				resourceUrl,
+				subParts
+			});
+			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;
+	return entry.url === "" ? void 0 : entry.url;
+}
+/**
+* Compute the LCP sub-parts breakdown (loadDelay, loadTime, renderDelay).
+* Returns undefined if navigation timing data or TTFB is unavailable.
+*/
+function computeLcpSubParts(resourceUrl, lcpValue) {
+	const firstByte = require_performanceUtils.sanitizeFirstByte(require_performanceUtils.getNavigationEntry());
+	if (firstByte === void 0) return;
+	const lcpResourceEntry = resourceUrl ? require_performanceUtils.findLcpResourceEntry(resourceUrl, lcpValue) : void 0;
+	const lcpRequestStart = lcpResourceEntry ? Math.max(firstByte, lcpResourceEntry.requestStart || lcpResourceEntry.startTime) : firstByte;
+	const lcpResponseEnd = Math.min(lcpValue, Math.max(lcpRequestStart, lcpResourceEntry?.responseEnd || 0));
+	return {
+		loadDelay: lcpRequestStart - firstByte,
+		loadTime: lcpResponseEnd - lcpRequestStart,
+		renderDelay: lcpValue - lcpResponseEnd
+	};
 }
+//#endregion
+exports.LCP_MAXIMUM_DELAY = LCP_MAXIMUM_DELAY;
+exports.trackLargestContentfulPaint = trackLargestContentfulPaint;
+
 //# sourceMappingURL=trackLargestContentfulPaint.js.map

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

@@ -1 +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"}
+{"version":3,"file":"trackLargestContentfulPaint.js","names":["ONE_MINUTE","addEventListeners","DOM_EVENT","createPerformanceObservable","findLast","getSelectorFromElement","sanitizeFirstByte","getNavigationEntry","findLcpResourceEntry"],"sources":["../../../../src/domain/view/viewMetrics/trackLargestContentfulPaint.ts"],"sourcesContent":["import type { RelativeTime } from '@kubesense/kubesense-js-core/time'\nimport { ONE_MINUTE } from '@kubesense/kubesense-js-core/time'\nimport { DOM_EVENT, addEventListeners, findLast } from '@kubesense/kubesense-browser-core'\nimport type { RumConfiguration } from '../../configuration'\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../../../browser/performanceObservable'\nimport { findLcpResourceEntry, getNavigationEntry, sanitizeFirstByte } from '../../../browser/performanceUtils'\nimport type { RumLargestContentfulPaintTiming } from '../../../browser/performanceObservable'\nimport { getSelectorFromElement } from '../../getSelectorFromElement'\nimport type { FirstHidden } from './trackFirstHidden'\n\n// Discard LCP timings above a certain delay to avoid incorrect data\n// It happens in some cases like sleep mode or some browser implementations\nexport const LCP_MAXIMUM_DELAY = 10 * ONE_MINUTE\n\nexport interface LargestContentfulPaint {\n  value: RelativeTime\n  targetSelector?: string\n  resourceUrl?: string\n  subParts?: {\n    loadDelay: RelativeTime\n    loadTime: RelativeTime\n    renderDelay: RelativeTime\n  }\n}\n\n/**\n * Track the largest contentful paint (LCP) occurring during the initial View.  This can yield\n * multiple values, only the most recent one should be used.\n * Documentation: https://web.dev/lcp/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/onLCP.ts\n */\nexport function trackLargestContentfulPaint(\n  configuration: RumConfiguration,\n  firstHidden: FirstHidden,\n  eventTarget: Window,\n  callback: (largestContentfulPaint: LargestContentfulPaint) => void\n) {\n  // Ignore entries that come after the first user interaction. According to the documentation, the\n  // browser should not send largest-contentful-paint entries after a user interact with the page,\n  // but the web-vitals reference implementation uses this as a safeguard.\n  let firstInteractionTimestamp = Infinity\n  const { stop: stopEventListener } = addEventListeners(\n    eventTarget,\n    [DOM_EVENT.POINTER_DOWN, DOM_EVENT.KEY_DOWN],\n    (event) => {\n      firstInteractionTimestamp = event.timeStamp\n    },\n    { capture: true, once: true }\n  )\n\n  let biggestLcpSize = 0\n  const performanceLcpSubscription = createPerformanceObservable({\n    type: RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT,\n    buffered: true,\n  }).subscribe((entries) => {\n    const lcpEntry = findLast(\n      entries,\n      (entry): entry is RumLargestContentfulPaintTiming =>\n        entry.entryType === RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT &&\n        entry.startTime < firstInteractionTimestamp &&\n        entry.startTime < firstHidden.timeStamp &&\n        entry.startTime < LCP_MAXIMUM_DELAY &&\n        // Ensure to get the LCP entry with the biggest size, see\n        // https://bugs.chromium.org/p/chromium/issues/detail?id=1516655\n        entry.size > biggestLcpSize\n    )\n    if (lcpEntry) {\n      let lcpTargetSelector\n      if (lcpEntry.element) {\n        lcpTargetSelector = getSelectorFromElement(lcpEntry.element, configuration.actionNameAttribute)\n      }\n\n      const resourceUrl = computeLcpEntryUrl(lcpEntry)\n      const lcpValue = lcpEntry.startTime\n\n      const subParts = computeLcpSubParts(resourceUrl, lcpValue)\n\n      callback({\n        value: lcpValue,\n        targetSelector: lcpTargetSelector,\n        resourceUrl,\n        subParts,\n      })\n      biggestLcpSize = lcpEntry.size\n    }\n  })\n\n  return {\n    stop: () => {\n      stopEventListener()\n      performanceLcpSubscription.unsubscribe()\n    },\n  }\n}\n\n// The property url report an empty string if the value is not available, we shouldn't report it in this case.\nfunction computeLcpEntryUrl(entry: RumLargestContentfulPaintTiming) {\n  return entry.url === '' ? undefined : entry.url\n}\n\n/**\n * Compute the LCP sub-parts breakdown (loadDelay, loadTime, renderDelay).\n * Returns undefined if navigation timing data or TTFB is unavailable.\n */\nfunction computeLcpSubParts(\n  resourceUrl: string | undefined,\n  lcpValue: RelativeTime\n): LargestContentfulPaint['subParts'] {\n  const firstByte = sanitizeFirstByte(getNavigationEntry())\n\n  if (firstByte === undefined) {\n    return undefined\n  }\n\n  const lcpResourceEntry = resourceUrl ? findLcpResourceEntry(resourceUrl, lcpValue) : undefined\n  const lcpRequestStart = lcpResourceEntry\n    ? (Math.max(firstByte, lcpResourceEntry.requestStart || lcpResourceEntry.startTime) as RelativeTime)\n    : firstByte\n\n  // Cap at LCP time to handle resources that continue downloading after LCP (e.g., videos)\n  const lcpResponseEnd = Math.min(lcpValue, Math.max(lcpRequestStart, lcpResourceEntry?.responseEnd || 0))\n\n  return {\n    loadDelay: (lcpRequestStart - firstByte) as RelativeTime,\n    loadTime: (lcpResponseEnd - lcpRequestStart) as RelativeTime,\n    renderDelay: (lcpValue - lcpResponseEnd) as RelativeTime,\n  }\n}\n"],"mappings":";;;;;;AAYA,MAAa,oBAAoB,KAAKA,kCAAAA;;;;;;;AAmBtC,SAAgB,4BACd,eACA,aACA,aACA,UACA;CAIA,IAAI,4BAA4B;CAChC,MAAM,EAAE,MAAM,uBAAA,GAAsBC,kCAAAA,kBAAAA,CAClC,aACA,CAACC,kCAAAA,UAAU,cAAcA,kCAAAA,UAAU,QAAQ,IAC1C,UAAU;EACT,4BAA4B,MAAM;CACpC,GACA;EAAE,SAAS;EAAM,MAAM;CAAK,CAC9B;CAEA,IAAI,iBAAiB;CACrB,MAAM,6BAA6BC,8BAAAA,4BAA4B;EAC7D,MAAA;EACA,UAAU;CACZ,CAAC,CAAC,CAAC,WAAW,YAAY;EACxB,MAAM,YAAA,GAAWC,kCAAAA,SAAAA,CACf,UACC,UACC,MAAM,cAAA,8BACN,MAAM,YAAY,6BAClB,MAAM,YAAY,YAAY,aAC9B,MAAM,YAAY,qBAGlB,MAAM,OAAO,cACjB;EACA,IAAI,UAAU;GACZ,IAAI;GACJ,IAAI,SAAS,SACX,oBAAoBC,+BAAAA,uBAAuB,SAAS,SAAS,cAAc,mBAAmB;GAGhG,MAAM,cAAc,mBAAmB,QAAQ;GAC/C,MAAM,WAAW,SAAS;GAE1B,MAAM,WAAW,mBAAmB,aAAa,QAAQ;GAEzD,SAAS;IACP,OAAO;IACP,gBAAgB;IAChB;IACA;GACF,CAAC;GACD,iBAAiB,SAAS;EAC5B;CACF,CAAC;CAED,OAAO,EACL,YAAY;EACV,kBAAkB;EAClB,2BAA2B,YAAY;CACzC,EACF;AACF;AAGA,SAAS,mBAAmB,OAAwC;CAClE,OAAO,MAAM,QAAQ,KAAK,KAAA,IAAY,MAAM;AAC9C;;;;;AAMA,SAAS,mBACP,aACA,UACoC;CACpC,MAAM,YAAYC,yBAAAA,kBAAkBC,yBAAAA,mBAAmB,CAAC;CAExD,IAAI,cAAc,KAAA,GAChB;CAGF,MAAM,mBAAmB,cAAcC,yBAAAA,qBAAqB,aAAa,QAAQ,IAAI,KAAA;CACrF,MAAM,kBAAkB,mBACnB,KAAK,IAAI,WAAW,iBAAiB,gBAAgB,iBAAiB,SAAS,IAChF;CAGJ,MAAM,iBAAiB,KAAK,IAAI,UAAU,KAAK,IAAI,iBAAiB,kBAAkB,eAAe,CAAC,CAAC;CAEvG,OAAO;EACL,WAAY,kBAAkB;EAC9B,UAAW,iBAAiB;EAC5B,aAAc,WAAW;CAC3B;AACF"}

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

@@ -1,4 +1,5 @@
-import type { ClocksState, Duration, Observable } from '@kubesense/kubesense-browser-core';
+import type { ClocksState, Duration } from '@kubesense/kubesense-js-core/time';
+import type { Observable } from '@kubesense/kubesense-browser-core';
 import type { RumConfiguration } from '../../configuration';
 import type { LifeCycle } from '../../lifeCycle';
 import { ViewLoadingType } from '../../../rawRumEvent.types';

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

@@ -1,50 +1,46 @@
-"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");
+const require_rawRumEvent_types = require("../../../rawRumEvent.types.js");
+const require_waitPageActivityEnd = require("../../waitPageActivityEnd.js");
+const require_trackFirstHidden = require("./trackFirstHidden.js");
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+//#region src/domain/view/viewMetrics/trackLoadingTime.ts
 /**
- * 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.
- */
+* 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();
-            }
-        },
-    };
+	let isWaitingForLoadEvent = loadType === require_rawRumEvent_types.ViewLoadingType.INITIAL_LOAD;
+	let isWaitingForActivityLoadingTime = true;
+	const loadingTimeCandidates = [];
+	const firstHidden = require_trackFirstHidden.trackFirstHidden(viewStart);
+	function invokeCallbackIfAllCandidatesAreReceived() {
+		if (!isWaitingForActivityLoadingTime && !isWaitingForLoadEvent && loadingTimeCandidates.length > 0) {
+			const loadingTime = Math.max(...loadingTimeCandidates);
+			if (loadingTime < firstHidden.timeStamp - viewStart.relative) callback(loadingTime);
+		}
+	}
+	const { stop } = require_waitPageActivityEnd.waitPageActivityEnd(lifeCycle, domMutationObservable, windowOpenObservable, configuration, (event) => {
+		if (isWaitingForActivityLoadingTime) {
+			isWaitingForActivityLoadingTime = false;
+			if (event.hadActivity) loadingTimeCandidates.push((0, _kubesense_kubesense_js_core_time.elapsed)(viewStart.timeStamp, event.end));
+			invokeCallbackIfAllCandidatesAreReceived();
+		}
+	});
+	return {
+		stop: () => {
+			stop();
+			firstHidden.stop();
+		},
+		setLoadEvent: (loadEvent) => {
+			if (isWaitingForLoadEvent) {
+				isWaitingForLoadEvent = false;
+				loadingTimeCandidates.push(loadEvent);
+				invokeCallbackIfAllCandidatesAreReceived();
+			}
+		}
+	};
 }
+//#endregion
+exports.trackLoadingTime = trackLoadingTime;
+
 //# sourceMappingURL=trackLoadingTime.js.map

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

@@ -1 +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"}
+{"version":3,"file":"trackLoadingTime.js","names":["ViewLoadingType","trackFirstHidden","waitPageActivityEnd","elapsed"],"sources":["../../../../src/domain/view/viewMetrics/trackLoadingTime.ts"],"sourcesContent":["import type { ClocksState, Duration } from '@kubesense/kubesense-js-core/time'\nimport type { Observable } from '@kubesense/kubesense-browser-core'\nimport { elapsed } from '@kubesense/kubesense-js-core/time'\nimport { waitPageActivityEnd } from '../../waitPageActivityEnd'\nimport type { RumConfiguration } from '../../configuration'\nimport type { LifeCycle } from '../../lifeCycle'\nimport { ViewLoadingType } from '../../../rawRumEvent.types'\nimport type { RumMutationRecord } from '../../../browser/domMutationObservable'\nimport { trackFirstHidden } from './trackFirstHidden'\n\n/**\n * For non-initial views (such as route changes or BFCache restores), the regular load event does not fire\n * In these cases, trackLoadingTime can only emit a loadingTime  if waitPageActivityEnd detects some post-restore activity.\n * If nothing happens after the view starts,no candidate is recorded and loadingTime stays undefined.\n */\n\nexport function trackLoadingTime(\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<RumMutationRecord[]>,\n  windowOpenObservable: Observable<void>,\n  configuration: RumConfiguration,\n  loadType: ViewLoadingType,\n  viewStart: ClocksState,\n  callback: (loadingTime: Duration) => void\n) {\n  let isWaitingForLoadEvent = loadType === ViewLoadingType.INITIAL_LOAD\n  let isWaitingForActivityLoadingTime = true\n  const loadingTimeCandidates: Duration[] = []\n  const firstHidden = trackFirstHidden(viewStart)\n\n  function invokeCallbackIfAllCandidatesAreReceived() {\n    if (!isWaitingForActivityLoadingTime && !isWaitingForLoadEvent && loadingTimeCandidates.length > 0) {\n      const loadingTime = Math.max(...loadingTimeCandidates)\n      // firstHidden is a relative time from time origin, so we use the relative start time of the view to compare with the loading time\n      if (loadingTime < firstHidden.timeStamp - viewStart.relative) {\n        callback(loadingTime as Duration)\n      }\n    }\n  }\n\n  const { stop } = waitPageActivityEnd(\n    lifeCycle,\n    domMutationObservable,\n    windowOpenObservable,\n    configuration,\n    (event) => {\n      if (isWaitingForActivityLoadingTime) {\n        isWaitingForActivityLoadingTime = false\n        if (event.hadActivity) {\n          loadingTimeCandidates.push(elapsed(viewStart.timeStamp, event.end))\n        }\n        invokeCallbackIfAllCandidatesAreReceived()\n      }\n    }\n  )\n\n  return {\n    stop: () => {\n      stop()\n      firstHidden.stop()\n    },\n    setLoadEvent: (loadEvent: Duration) => {\n      if (isWaitingForLoadEvent) {\n        isWaitingForLoadEvent = false\n        loadingTimeCandidates.push(loadEvent)\n        invokeCallbackIfAllCandidatesAreReceived()\n      }\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;AAgBA,SAAgB,iBACd,WACA,uBACA,sBACA,eACA,UACA,WACA,UACA;CACA,IAAI,wBAAwB,aAAaA,0BAAAA,gBAAgB;CACzD,IAAI,kCAAkC;CACtC,MAAM,wBAAoC,CAAC;CAC3C,MAAM,cAAcC,yBAAAA,iBAAiB,SAAS;CAE9C,SAAS,2CAA2C;EAClD,IAAI,CAAC,mCAAmC,CAAC,yBAAyB,sBAAsB,SAAS,GAAG;GAClG,MAAM,cAAc,KAAK,IAAI,GAAG,qBAAqB;GAErD,IAAI,cAAc,YAAY,YAAY,UAAU,UAClD,SAAS,WAAuB;EAEpC;CACF;CAEA,MAAM,EAAE,SAASC,4BAAAA,oBACf,WACA,uBACA,sBACA,gBACC,UAAU;EACT,IAAI,iCAAiC;GACnC,kCAAkC;GAClC,IAAI,MAAM,aACR,sBAAsB,MAAA,GAAKC,kCAAAA,QAAAA,CAAQ,UAAU,WAAW,MAAM,GAAG,CAAC;GAEpE,yCAAyC;EAC3C;CACF,CACF;CAEA,OAAO;EACL,YAAY;GACV,KAAK;GACL,YAAY,KAAK;EACnB;EACA,eAAe,cAAwB;GACrC,IAAI,uBAAuB;IACzB,wBAAwB;IACxB,sBAAsB,KAAK,SAAS;IACpC,yCAAyC;GAC3C;EACF;CACF;AACF"}

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

@@ -1,6 +1,5 @@
-import type { Duration } from '@kubesense/kubesense-browser-core';
+import type { Duration } from '@kubesense/kubesense-js-core/time';
 import type { RumPerformanceNavigationTiming } from '../../../browser/performanceObservable';
-import type { RumConfiguration } from '../../configuration';
 export interface NavigationTimings {
     domComplete: Duration;
     domContentLoaded: Duration;
@@ -9,6 +8,6 @@ export interface NavigationTimings {
     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): {
+export declare function trackNavigationTimings(callback: (timings: NavigationTimings) => void): {
     stop: () => void;
 };

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

@@ -1,43 +1,35 @@
-"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));
-        }
-    });
+const require_performanceUtils = require("../../../browser/performanceUtils.js");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+//#region src/domain/view/viewMetrics/trackNavigationTimings.ts
+function trackNavigationTimings(callback) {
+	return waitAfterLoadEvent(() => {
+		const entry = (0, _kubesense_kubesense_browser_core.mockable)(require_performanceUtils.getNavigationEntry)();
+		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,
-    };
+	return {
+		domComplete: entry.domComplete,
+		domContentLoaded: entry.domContentLoadedEventEnd,
+		domInteractive: entry.domInteractive,
+		loadEvent: entry.loadEventEnd,
+		firstByte: require_performanceUtils.sanitizeFirstByte(entry)
+	};
 }
 function isIncompleteNavigation(entry) {
-    return entry.loadEventEnd <= 0;
+	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);
-        },
-    };
+function waitAfterLoadEvent(callback) {
+	let timeoutId;
+	const { stop: stopOnReadyState } = (0, _kubesense_kubesense_browser_core.runOnReadyState)("complete", () => {
+		timeoutId = (0, _kubesense_kubesense_browser_core.setTimeout)(() => callback());
+	});
+	return { stop: () => {
+		stopOnReadyState();
+		(0, _kubesense_kubesense_browser_core.clearTimeout)(timeoutId);
+	} };
 }
+//#endregion
+exports.trackNavigationTimings = trackNavigationTimings;
+
 //# sourceMappingURL=trackNavigationTimings.js.map

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

@@ -1 +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"}
+{"version":3,"file":"trackNavigationTimings.js","names":["mockable","getNavigationEntry","sanitizeFirstByte","runOnReadyState","setTimeout"],"sources":["../../../../src/domain/view/viewMetrics/trackNavigationTimings.ts"],"sourcesContent":["import type { TimeoutId } from '@kubesense/kubesense-browser-core'\nimport type { Duration } from '@kubesense/kubesense-js-core/time'\nimport { setTimeout, runOnReadyState, clearTimeout, mockable } from '@kubesense/kubesense-browser-core'\nimport type { RumPerformanceNavigationTiming } from '../../../browser/performanceObservable'\nimport { getNavigationEntry, sanitizeFirstByte } from '../../../browser/performanceUtils'\n\nexport interface NavigationTimings {\n  domComplete: Duration\n  domContentLoaded: Duration\n  domInteractive: Duration\n  loadEvent: Duration\n  firstByte: Duration | undefined\n}\n\n// This is a subset of \"RumPerformanceNavigationTiming\" that only contains the relevant fields for\n// computing navigation timings. This is useful to mock the navigation entry in tests.\nexport type RelevantNavigationTiming = Pick<\n  RumPerformanceNavigationTiming,\n  'domComplete' | 'domContentLoadedEventEnd' | 'domInteractive' | 'loadEventEnd' | 'responseStart'\n>\n\nexport function trackNavigationTimings(callback: (timings: NavigationTimings) => void) {\n  return waitAfterLoadEvent(() => {\n    const entry = mockable(getNavigationEntry)()\n\n    if (!isIncompleteNavigation(entry)) {\n      callback(processNavigationEntry(entry))\n    }\n  })\n}\n\nfunction processNavigationEntry(entry: RelevantNavigationTiming): NavigationTimings {\n  return {\n    domComplete: entry.domComplete,\n    domContentLoaded: entry.domContentLoadedEventEnd,\n    domInteractive: entry.domInteractive,\n    loadEvent: entry.loadEventEnd,\n    firstByte: sanitizeFirstByte(entry),\n  }\n}\n\nfunction isIncompleteNavigation(entry: RelevantNavigationTiming) {\n  return entry.loadEventEnd <= 0\n}\n\nfunction waitAfterLoadEvent(callback: () => void) {\n  let timeoutId: TimeoutId | undefined\n  const { stop: stopOnReadyState } = runOnReadyState('complete', () => {\n    // Invoke the callback a bit after the actual load event, so the \"loadEventEnd\" timing is accurate\n    timeoutId = setTimeout(() => callback())\n  })\n  return {\n    stop: () => {\n      stopOnReadyState()\n      clearTimeout(timeoutId)\n    },\n  }\n}\n"],"mappings":";;;AAqBA,SAAgB,uBAAuB,UAAgD;CACrF,OAAO,yBAAyB;EAC9B,MAAM,SAAA,GAAQA,kCAAAA,SAAAA,CAASC,yBAAAA,kBAAkB,CAAC,CAAC;EAE3C,IAAI,CAAC,uBAAuB,KAAK,GAC/B,SAAS,uBAAuB,KAAK,CAAC;CAE1C,CAAC;AACH;AAEA,SAAS,uBAAuB,OAAoD;CAClF,OAAO;EACL,aAAa,MAAM;EACnB,kBAAkB,MAAM;EACxB,gBAAgB,MAAM;EACtB,WAAW,MAAM;EACjB,WAAWC,yBAAAA,kBAAkB,KAAK;CACpC;AACF;AAEA,SAAS,uBAAuB,OAAiC;CAC/D,OAAO,MAAM,gBAAgB;AAC/B;AAEA,SAAS,mBAAmB,UAAsB;CAChD,IAAI;CACJ,MAAM,EAAE,MAAM,sBAAA,GAAqBC,kCAAAA,gBAAAA,CAAgB,kBAAkB;EAEnE,aAAA,GAAYC,kCAAAA,WAAAA,OAAiB,SAAS,CAAC;CACzC,CAAC;CACD,OAAO,EACL,YAAY;EACV,iBAAiB;EACjB,CAAA,GAAA,kCAAA,aAAA,CAAa,SAAS;CACxB,EACF;AACF"}

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

@@ -1,6 +1,5 @@
-import type { ClocksState, Duration } from '@kubesense/kubesense-browser-core';
+import type { Duration, ClocksState } from '@kubesense/kubesense-js-core/time';
 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 {
@@ -9,7 +8,7 @@ export interface ScrollMetrics {
     maxDepthScrollTop: number;
     maxScrollHeightTime: Duration;
 }
-export declare function trackScrollMetrics(configuration: RumConfiguration, viewStart: ClocksState, callback: (scrollMetrics: ScrollMetrics) => void, scrollValues?: Observable<ScrollValues>): {
+export declare function trackScrollMetrics(viewStart: ClocksState, callback: (scrollMetrics: ScrollMetrics) => void, scrollValues?: Observable<ScrollValues>): {
     stop: () => void;
 };
 export interface ScrollValues {
@@ -22,4 +21,4 @@ export declare function computeScrollValues(): {
     scrollDepth: number;
     scrollTop: number;
 };
-export declare function createScrollValuesObservable(configuration: RumConfiguration, throttleDuration?: number): Observable<ScrollValues>;
+export declare function createScrollValuesObservable(throttleDuration?: number): Observable<ScrollValues>;