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

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

@@ -0,0 +1 @@
+{"version":3,"file":"trackInteractionToNextPaint.mjs","names":[],"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/esm/domain/view/viewMetrics/trackLargestContentfulPaint.mjs

@@ -0,0 +1,70 @@
+import { createPerformanceObservable } from "../../../browser/performanceObservable.mjs";
+import { getSelectorFromElement } from "../../getSelectorFromElement.mjs";
+import { findLcpResourceEntry, getNavigationEntry, sanitizeFirstByte } from "../../../browser/performanceUtils.mjs";
+import { ONE_MINUTE } from "@kubesense/kubesense-js-core/time";
+import { DOM_EVENT, addEventListeners, findLast } from "@kubesense/kubesense-browser-core";
+//#region src/domain/view/viewMetrics/trackLargestContentfulPaint.ts
+const LCP_MAXIMUM_DELAY = 10 * 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) {
+	let firstInteractionTimestamp = Infinity;
+	const { stop: stopEventListener } = addEventListeners(eventTarget, [DOM_EVENT.POINTER_DOWN, DOM_EVENT.KEY_DOWN], (event) => {
+		firstInteractionTimestamp = event.timeStamp;
+	}, {
+		capture: true,
+		once: true
+	});
+	let biggestLcpSize = 0;
+	const performanceLcpSubscription = createPerformanceObservable({
+		type: "largest-contentful-paint",
+		buffered: true
+	}).subscribe((entries) => {
+		const lcpEntry = 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 = 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();
+	} };
+}
+function computeLcpEntryUrl(entry) {
+	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 = sanitizeFirstByte(getNavigationEntry());
+	if (firstByte === void 0) return;
+	const lcpResourceEntry = resourceUrl ? 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
+export { LCP_MAXIMUM_DELAY, trackLargestContentfulPaint };
+
+//# sourceMappingURL=trackLargestContentfulPaint.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trackLargestContentfulPaint.mjs","names":[],"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,KAAK;;;;;;;AAmBtC,SAAgB,4BACd,eACA,aACA,aACA,UACA;CAIA,IAAI,4BAA4B;CAChC,MAAM,EAAE,MAAM,sBAAsB,kBAClC,aACA,CAAC,UAAU,cAAc,UAAU,QAAQ,IAC1C,UAAU;EACT,4BAA4B,MAAM;CACpC,GACA;EAAE,SAAS;EAAM,MAAM;CAAK,CAC9B;CAEA,IAAI,iBAAiB;CACrB,MAAM,6BAA6B,4BAA4B;EAC7D,MAAA;EACA,UAAU;CACZ,CAAC,CAAC,CAAC,WAAW,YAAY;EACxB,MAAM,WAAW,SACf,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,oBAAoB,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,YAAY,kBAAkB,mBAAmB,CAAC;CAExD,IAAI,cAAc,KAAA,GAChB;CAGF,MAAM,mBAAmB,cAAc,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/esm/domain/view/viewMetrics/trackLoadingTime.mjs

@@ -0,0 +1,46 @@
+import { ViewLoadingType } from "../../../rawRumEvent.types.mjs";
+import { waitPageActivityEnd } from "../../waitPageActivityEnd.mjs";
+import { trackFirstHidden } from "./trackFirstHidden.mjs";
+import { elapsed } from "@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.
+*/
+function trackLoadingTime(lifeCycle, domMutationObservable, windowOpenObservable, configuration, loadType, viewStart, callback) {
+	let isWaitingForLoadEvent = loadType === ViewLoadingType.INITIAL_LOAD;
+	let isWaitingForActivityLoadingTime = true;
+	const loadingTimeCandidates = [];
+	const firstHidden = 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 } = waitPageActivityEnd(lifeCycle, domMutationObservable, windowOpenObservable, configuration, (event) => {
+		if (isWaitingForActivityLoadingTime) {
+			isWaitingForActivityLoadingTime = false;
+			if (event.hadActivity) loadingTimeCandidates.push(elapsed(viewStart.timeStamp, event.end));
+			invokeCallbackIfAllCandidatesAreReceived();
+		}
+	});
+	return {
+		stop: () => {
+			stop();
+			firstHidden.stop();
+		},
+		setLoadEvent: (loadEvent) => {
+			if (isWaitingForLoadEvent) {
+				isWaitingForLoadEvent = false;
+				loadingTimeCandidates.push(loadEvent);
+				invokeCallbackIfAllCandidatesAreReceived();
+			}
+		}
+	};
+}
+//#endregion
+export { trackLoadingTime };
+
+//# sourceMappingURL=trackLoadingTime.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trackLoadingTime.mjs","names":[],"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,aAAa,gBAAgB;CACzD,IAAI,kCAAkC;CACtC,MAAM,wBAAoC,CAAC;CAC3C,MAAM,cAAc,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,SAAS,oBACf,WACA,uBACA,sBACA,gBACC,UAAU;EACT,IAAI,iCAAiC;GACnC,kCAAkC;GAClC,IAAI,MAAM,aACR,sBAAsB,KAAK,QAAQ,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/esm/domain/view/viewMetrics/trackNavigationTimings.mjs

@@ -0,0 +1,35 @@
+import { getNavigationEntry, sanitizeFirstByte } from "../../../browser/performanceUtils.mjs";
+import { clearTimeout, mockable, runOnReadyState, setTimeout } from "@kubesense/kubesense-browser-core";
+//#region src/domain/view/viewMetrics/trackNavigationTimings.ts
+function trackNavigationTimings(callback) {
+	return waitAfterLoadEvent(() => {
+		const entry = mockable(getNavigationEntry)();
+		if (!isIncompleteNavigation(entry)) callback(processNavigationEntry(entry));
+	});
+}
+function processNavigationEntry(entry) {
+	return {
+		domComplete: entry.domComplete,
+		domContentLoaded: entry.domContentLoadedEventEnd,
+		domInteractive: entry.domInteractive,
+		loadEvent: entry.loadEventEnd,
+		firstByte: sanitizeFirstByte(entry)
+	};
+}
+function isIncompleteNavigation(entry) {
+	return entry.loadEventEnd <= 0;
+}
+function waitAfterLoadEvent(callback) {
+	let timeoutId;
+	const { stop: stopOnReadyState } = runOnReadyState("complete", () => {
+		timeoutId = setTimeout(() => callback());
+	});
+	return { stop: () => {
+		stopOnReadyState();
+		clearTimeout(timeoutId);
+	} };
+}
+//#endregion
+export { trackNavigationTimings };
+
+//# sourceMappingURL=trackNavigationTimings.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trackNavigationTimings.mjs","names":[],"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,QAAQ,SAAS,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,WAAW,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,qBAAqB,gBAAgB,kBAAkB;EAEnE,YAAY,iBAAiB,SAAS,CAAC;CACzC,CAAC;CACD,OAAO,EACL,YAAY;EACV,iBAAiB;EACjB,aAAa,SAAS;CACxB,EACF;AACF"}

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

@@ -0,0 +1,66 @@
+import { getScrollY } from "../../../browser/scroll.mjs";
+import { getViewportDimension } from "../../../browser/viewportObservable.mjs";
+import { ONE_SECOND, elapsed, relativeNow } from "@kubesense/kubesense-js-core/time";
+import { DOM_EVENT, Observable, addEventListener, throttle } from "@kubesense/kubesense-browser-core";
+import { monitor } from "@kubesense/kubesense-js-core/monitor";
+//#region src/domain/view/viewMetrics/trackScrollMetrics.ts
+/** Arbitrary scroll throttle duration */
+const THROTTLE_SCROLL_DURATION = ONE_SECOND;
+function trackScrollMetrics(viewStart, callback, scrollValues = createScrollValuesObservable()) {
+	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 = relativeNow();
+			maxScrollHeightTime = 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 = getScrollY();
+	const { height } = getViewportDimension();
+	return {
+		scrollHeight: Math.round((document.scrollingElement || document.documentElement).scrollHeight),
+		scrollDepth: Math.round(height + scrollTop),
+		scrollTop
+	};
+}
+function createScrollValuesObservable(throttleDuration = THROTTLE_SCROLL_DURATION) {
+	return new Observable((observable) => {
+		function notify() {
+			observable.notify(computeScrollValues());
+		}
+		const throttledNotify = throttle(notify, throttleDuration, {
+			leading: false,
+			trailing: true
+		});
+		const observerTarget = document.scrollingElement || document.documentElement;
+		const resizeObserver = new ResizeObserver(monitor(throttledNotify.throttled));
+		if (observerTarget) resizeObserver.observe(observerTarget);
+		const eventListener = addEventListener(window, DOM_EVENT.SCROLL, throttledNotify.throttled, { passive: true });
+		return () => {
+			throttledNotify.cancel();
+			resizeObserver.disconnect();
+			eventListener.stop();
+		};
+	});
+}
+//#endregion
+export { THROTTLE_SCROLL_DURATION, computeScrollValues, createScrollValuesObservable, trackScrollMetrics };
+
+//# sourceMappingURL=trackScrollMetrics.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trackScrollMetrics.mjs","names":[],"sources":["../../../../src/domain/view/viewMetrics/trackScrollMetrics.ts"],"sourcesContent":["import { ONE_SECOND, elapsed, relativeNow } from '@kubesense/kubesense-js-core/time'\nimport type { Duration, ClocksState } from '@kubesense/kubesense-js-core/time'\nimport { monitor } from '@kubesense/kubesense-js-core/monitor'\nimport { Observable, throttle, addEventListener, DOM_EVENT } from '@kubesense/kubesense-browser-core'\nimport { getScrollY } from '../../../browser/scroll'\nimport { getViewportDimension } from '../../../browser/viewportObservable'\n\n/** Arbitrary scroll throttle duration */\nexport const THROTTLE_SCROLL_DURATION = ONE_SECOND\n\nexport interface ScrollMetrics {\n  maxDepth: number\n  maxScrollHeight: number\n  maxDepthScrollTop: number\n  maxScrollHeightTime: Duration\n}\n\nexport function trackScrollMetrics(\n  viewStart: ClocksState,\n  callback: (scrollMetrics: ScrollMetrics) => void,\n  scrollValues = createScrollValuesObservable()\n) {\n  let maxScrollDepth = 0\n  let maxScrollHeight = 0\n  let maxScrollHeightTime = 0 as Duration\n\n  const subscription = scrollValues.subscribe(({ scrollDepth, scrollTop, scrollHeight }) => {\n    let shouldUpdate = false\n\n    if (scrollDepth > maxScrollDepth) {\n      maxScrollDepth = scrollDepth\n      shouldUpdate = true\n    }\n\n    if (scrollHeight > maxScrollHeight) {\n      maxScrollHeight = scrollHeight\n      const now = relativeNow()\n      maxScrollHeightTime = elapsed(viewStart.relative, now)\n      shouldUpdate = true\n    }\n\n    if (shouldUpdate) {\n      callback({\n        maxDepth: Math.min(maxScrollDepth, maxScrollHeight),\n        maxDepthScrollTop: scrollTop,\n        maxScrollHeight,\n        maxScrollHeightTime,\n      })\n    }\n  })\n\n  return {\n    stop: () => subscription.unsubscribe(),\n  }\n}\n\nexport interface ScrollValues {\n  scrollDepth: number\n  scrollTop: number\n  scrollHeight: number\n}\n\nexport function computeScrollValues() {\n  const scrollTop = getScrollY()\n\n  const { height } = getViewportDimension()\n\n  const scrollHeight = Math.round((document.scrollingElement || document.documentElement).scrollHeight)\n\n  const scrollDepth = Math.round(height + scrollTop)\n\n  return {\n    scrollHeight,\n    scrollDepth,\n    scrollTop,\n  }\n}\n\nexport function createScrollValuesObservable(throttleDuration = THROTTLE_SCROLL_DURATION): Observable<ScrollValues> {\n  return new Observable<ScrollValues>((observable) => {\n    function notify() {\n      observable.notify(computeScrollValues())\n    }\n\n    const throttledNotify = throttle(notify, throttleDuration, {\n      leading: false,\n      trailing: true,\n    })\n\n    const observerTarget = document.scrollingElement || document.documentElement\n    const resizeObserver = new ResizeObserver(monitor(throttledNotify.throttled))\n    if (observerTarget) {\n      resizeObserver.observe(observerTarget)\n    }\n    const eventListener = addEventListener(window, DOM_EVENT.SCROLL, throttledNotify.throttled, {\n      passive: true,\n    })\n\n    return () => {\n      throttledNotify.cancel()\n      resizeObserver.disconnect()\n      eventListener.stop()\n    }\n  })\n}\n"],"mappings":";;;;;;;AAQA,MAAa,2BAA2B;AASxC,SAAgB,mBACd,WACA,UACA,eAAe,6BAA6B,GAC5C;CACA,IAAI,iBAAiB;CACrB,IAAI,kBAAkB;CACtB,IAAI,sBAAsB;CAE1B,MAAM,eAAe,aAAa,WAAW,EAAE,aAAa,WAAW,mBAAmB;EACxF,IAAI,eAAe;EAEnB,IAAI,cAAc,gBAAgB;GAChC,iBAAiB;GACjB,eAAe;EACjB;EAEA,IAAI,eAAe,iBAAiB;GAClC,kBAAkB;GAClB,MAAM,MAAM,YAAY;GACxB,sBAAsB,QAAQ,UAAU,UAAU,GAAG;GACrD,eAAe;EACjB;EAEA,IAAI,cACF,SAAS;GACP,UAAU,KAAK,IAAI,gBAAgB,eAAe;GAClD,mBAAmB;GACnB;GACA;EACF,CAAC;CAEL,CAAC;CAED,OAAO,EACL,YAAY,aAAa,YAAY,EACvC;AACF;AAQA,SAAgB,sBAAsB;CACpC,MAAM,YAAY,WAAW;CAE7B,MAAM,EAAE,WAAW,qBAAqB;CAMxC,OAAO;EACL,cALmB,KAAK,OAAO,SAAS,oBAAoB,SAAS,gBAAA,CAAiB,YAK3E;EACX,aAJkB,KAAK,MAAM,SAAS,SAI5B;EACV;CACF;AACF;AAEA,SAAgB,6BAA6B,mBAAmB,0BAAoD;CAClH,OAAO,IAAI,YAA0B,eAAe;EAClD,SAAS,SAAS;GAChB,WAAW,OAAO,oBAAoB,CAAC;EACzC;EAEA,MAAM,kBAAkB,SAAS,QAAQ,kBAAkB;GACzD,SAAS;GACT,UAAU;EACZ,CAAC;EAED,MAAM,iBAAiB,SAAS,oBAAoB,SAAS;EAC7D,MAAM,iBAAiB,IAAI,eAAe,QAAQ,gBAAgB,SAAS,CAAC;EAC5E,IAAI,gBACF,eAAe,QAAQ,cAAc;EAEvC,MAAM,gBAAgB,iBAAiB,QAAQ,UAAU,QAAQ,gBAAgB,WAAW,EAC1F,SAAS,KACX,CAAC;EAED,aAAa;GACX,gBAAgB,OAAO;GACvB,eAAe,WAAW;GAC1B,cAAc,KAAK;EACrB;CACF,CAAC;AACH"}

package/esm/domain/vital/vitalCollection.mjs

@@ -0,0 +1,85 @@
+import { RumEventType, VitalType } from "../../rawRumEvent.types.mjs";
+import "../lifeCycle.mjs";
+import { startEventTracker } from "../eventTracker.mjs";
+import "../contexts/pageStateHistory.mjs";
+import { clocksNow, toServerDuration } from "@kubesense/kubesense-js-core/time";
+import { generateUUID, sanitize } from "@kubesense/kubesense-browser-core";
+//#region src/domain/vital/vitalCollection.ts
+function startVitalCollection(lifeCycle, pageStateHistory) {
+	const vitalTracker = startEventTracker(lifeCycle);
+	function isValid(vital) {
+		return !pageStateHistory.wasInPageStateDuringPeriod("frozen", vital.startClocks.relative, vital.duration);
+	}
+	function addDurationVital(vital) {
+		if (isValid(vital)) lifeCycle.notify(13, processVital(vital));
+	}
+	function addOperationStepVital(name, stepType, options, failureReason) {
+		const { operationKey, context, description, handlingStack } = options || {};
+		const vital = {
+			name,
+			type: VitalType.OPERATION_STEP,
+			operationKey,
+			failureReason,
+			stepType,
+			startClocks: clocksNow(),
+			context: sanitize(context),
+			description,
+			handlingStack
+		};
+		lifeCycle.notify(13, processVital(vital));
+	}
+	function startDurationVital(name, options = {}, startClocks = clocksNow()) {
+		const { id } = vitalTracker.start(options.vitalKey ?? name, startClocks, {
+			name,
+			...options
+		});
+		lifeCycle.notify(17, {
+			id,
+			name,
+			startClocks,
+			...options
+		});
+	}
+	function stopDurationVital(name, options = {}, stopClocks = clocksNow()) {
+		const stopped = vitalTracker.stop(options.vitalKey ?? name, stopClocks, options);
+		if (stopped) addDurationVital({
+			type: VitalType.DURATION,
+			...stopped
+		});
+	}
+	return {
+		addOperationStepVital,
+		addDurationVital,
+		startDurationVital,
+		stopDurationVital
+	};
+}
+function processVital(vital) {
+	const { startClocks, type, name, description, context, handlingStack } = vital;
+	const vitalData = {
+		id: (vital.type === VitalType.DURATION ? vital.id : void 0) ?? generateUUID(),
+		type,
+		name,
+		description,
+		...type === VitalType.DURATION ? { duration: toServerDuration(vital.duration) } : {
+			step_type: vital.stepType,
+			operation_key: vital.operationKey,
+			failure_reason: vital.failureReason
+		}
+	};
+	return {
+		rawRumEvent: {
+			date: startClocks.timeStamp,
+			vital: vitalData,
+			type: RumEventType.VITAL,
+			context
+		},
+		startClocks,
+		duration: type === VitalType.DURATION ? vital.duration : void 0,
+		domainContext: handlingStack ? { handlingStack } : {}
+	};
+}
+//#endregion
+export { startVitalCollection };
+
+//# sourceMappingURL=vitalCollection.mjs.map

package/esm/domain/vital/vitalCollection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitalCollection.mjs","names":[],"sources":["../../../src/domain/vital/vitalCollection.ts"],"sourcesContent":["import type { ClocksState, Duration } from '@kubesense/kubesense-js-core/time'\nimport { toServerDuration, clocksNow } from '@kubesense/kubesense-js-core/time'\nimport { generateUUID, sanitize } from '@kubesense/kubesense-browser-core'\nimport type { LifeCycle, RawRumEventCollectedData } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport type { RawRumVitalEvent } from '../../rawRumEvent.types'\nimport { RumEventType, VitalType } from '../../rawRumEvent.types'\nimport type { PageStateHistory } from '../contexts/pageStateHistory'\nimport { PageState } from '../contexts/pageStateHistory'\nimport { startEventTracker } from '../eventTracker'\n\n/**\n * Vital options\n */\nexport interface VitalOptions {\n  /**\n   * Vital context\n   */\n  context?: any\n\n  /**\n   * Vital description\n   */\n  description?: string\n}\n\n/**\n * Duration vital options\n */\nexport interface DurationVitalOptions extends VitalOptions {\n  /**\n   * Vital key, used to identify a specific vital instance when multiple vitals with the same name\n   * are tracked simultaneously\n   */\n  vitalKey?: string\n}\n\nexport interface OperationOptions extends VitalOptions {\n  operationKey?: string\n}\n\n/** @deprecated Use {@link OperationOptions} instead. */\nexport type FeatureOperationOptions = OperationOptions\n\nexport type FailureReason = 'error' | 'abandoned' | 'other'\n\n/**\n * Add duration vital options\n */\nexport interface AddDurationVitalOptions extends DurationVitalOptions {\n  /**\n   * Vital start time, expects a UNIX timestamp in milliseconds (the number of milliseconds since January 1, 1970)\n   */\n  startTime: number\n\n  /**\n   * Vital duration, expects a duration in milliseconds\n   */\n  duration: number\n}\n\nexport interface DurationVitalStart extends DurationVitalOptions {\n  id: string\n  name: string\n  startClocks: ClocksState\n  handlingStack?: string\n}\n\ninterface BaseVital extends VitalOptions {\n  name: string\n  startClocks: ClocksState\n  handlingStack?: string\n}\nexport interface DurationVital extends BaseVital {\n  id: string\n  type: typeof VitalType.DURATION\n  duration: Duration\n}\n\nexport interface OperationStepVital extends BaseVital {\n  type: typeof VitalType.OPERATION_STEP\n  stepType: 'start' | 'end'\n  operationKey?: string\n  failureReason?: string\n}\n\ninterface DurationVitalData {\n  name: string\n  context?: any\n  description?: string\n  handlingStack?: string\n}\n\nexport function startVitalCollection(lifeCycle: LifeCycle, pageStateHistory: PageStateHistory) {\n  const vitalTracker = startEventTracker<DurationVitalData>(lifeCycle)\n\n  function isValid(vital: DurationVital) {\n    return !pageStateHistory.wasInPageStateDuringPeriod(PageState.FROZEN, vital.startClocks.relative, vital.duration)\n  }\n\n  function addDurationVital(vital: DurationVital) {\n    if (isValid(vital)) {\n      lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, processVital(vital))\n    }\n  }\n\n  function addOperationStepVital(\n    name: string,\n    stepType: 'start' | 'end',\n    options?: OperationOptions & { handlingStack?: string },\n    failureReason?: FailureReason\n  ) {\n    const { operationKey, context, description, handlingStack } = options || {}\n\n    const vital: OperationStepVital = {\n      name,\n      type: VitalType.OPERATION_STEP,\n      operationKey,\n      failureReason,\n      stepType,\n      startClocks: clocksNow(),\n      context: sanitize(context),\n      description,\n      handlingStack,\n    }\n    lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, processVital(vital))\n  }\n\n  function startDurationVital(\n    name: string,\n    options: DurationVitalOptions & { handlingStack?: string } = {},\n    startClocks = clocksNow()\n  ) {\n    const { id } = vitalTracker.start(options.vitalKey ?? name, startClocks, {\n      name,\n      ...options,\n    })\n    lifeCycle.notify(LifeCycleEventType.DURATION_VITAL_STARTED, { id, name, startClocks, ...options })\n  }\n\n  function stopDurationVital(name: string, options: DurationVitalOptions = {}, stopClocks = clocksNow()) {\n    const stopped = vitalTracker.stop(options.vitalKey ?? name, stopClocks, options)\n    if (stopped) {\n      addDurationVital({\n        type: VitalType.DURATION,\n        ...stopped,\n      })\n    }\n  }\n\n  return {\n    addOperationStepVital,\n    addDurationVital,\n    startDurationVital,\n    stopDurationVital,\n  }\n}\n\nfunction processVital(vital: DurationVital | OperationStepVital): RawRumEventCollectedData<RawRumVitalEvent> {\n  const { startClocks, type, name, description, context, handlingStack } = vital\n  const vitalId = vital.type === VitalType.DURATION ? vital.id : undefined\n\n  const vitalData = {\n    id: vitalId ?? generateUUID(),\n    type,\n    name,\n    description,\n    ...(type === VitalType.DURATION\n      ? { duration: toServerDuration(vital.duration) }\n      : {\n          step_type: vital.stepType,\n          operation_key: vital.operationKey,\n          failure_reason: vital.failureReason,\n        }),\n  }\n\n  return {\n    rawRumEvent: {\n      date: startClocks.timeStamp,\n      vital: vitalData,\n      type: RumEventType.VITAL,\n      context,\n    },\n    startClocks,\n    duration: type === VitalType.DURATION ? vital.duration : undefined,\n    domainContext: handlingStack ? { handlingStack } : {},\n  }\n}\n"],"mappings":";;;;;;;AA6FA,SAAgB,qBAAqB,WAAsB,kBAAoC;CAC7F,MAAM,eAAe,kBAAqC,SAAS;CAEnE,SAAS,QAAQ,OAAsB;EACrC,OAAO,CAAC,iBAAiB,2BAAA,UAA6C,MAAM,YAAY,UAAU,MAAM,QAAQ;CAClH;CAEA,SAAS,iBAAiB,OAAsB;EAC9C,IAAI,QAAQ,KAAK,GACf,UAAU,OAAA,IAAmD,aAAa,KAAK,CAAC;CAEpF;CAEA,SAAS,sBACP,MACA,UACA,SACA,eACA;EACA,MAAM,EAAE,cAAc,SAAS,aAAa,kBAAkB,WAAW,CAAC;EAE1E,MAAM,QAA4B;GAChC;GACA,MAAM,UAAU;GAChB;GACA;GACA;GACA,aAAa,UAAU;GACvB,SAAS,SAAS,OAAO;GACzB;GACA;EACF;EACA,UAAU,OAAA,IAAmD,aAAa,KAAK,CAAC;CAClF;CAEA,SAAS,mBACP,MACA,UAA6D,CAAC,GAC9D,cAAc,UAAU,GACxB;EACA,MAAM,EAAE,OAAO,aAAa,MAAM,QAAQ,YAAY,MAAM,aAAa;GACvE;GACA,GAAG;EACL,CAAC;EACD,UAAU,OAAA,IAAkD;GAAE;GAAI;GAAM;GAAa,GAAG;EAAQ,CAAC;CACnG;CAEA,SAAS,kBAAkB,MAAc,UAAgC,CAAC,GAAG,aAAa,UAAU,GAAG;EACrG,MAAM,UAAU,aAAa,KAAK,QAAQ,YAAY,MAAM,YAAY,OAAO;EAC/E,IAAI,SACF,iBAAiB;GACf,MAAM,UAAU;GAChB,GAAG;EACL,CAAC;CAEL;CAEA,OAAO;EACL;EACA;EACA;EACA;CACF;AACF;AAEA,SAAS,aAAa,OAAuF;CAC3G,MAAM,EAAE,aAAa,MAAM,MAAM,aAAa,SAAS,kBAAkB;CAGzE,MAAM,YAAY;EAChB,KAHc,MAAM,SAAS,UAAU,WAAW,MAAM,KAAK,KAAA,MAG9C,aAAa;EAC5B;EACA;EACA;EACA,GAAI,SAAS,UAAU,WACnB,EAAE,UAAU,iBAAiB,MAAM,QAAQ,EAAE,IAC7C;GACE,WAAW,MAAM;GACjB,eAAe,MAAM;GACrB,gBAAgB,MAAM;EACxB;CACN;CAEA,OAAO;EACL,aAAa;GACX,MAAM,YAAY;GAClB,OAAO;GACP,MAAM,aAAa;GACnB;EACF;EACA;EACA,UAAU,SAAS,UAAU,WAAW,MAAM,WAAW,KAAA;EACzD,eAAe,gBAAgB,EAAE,cAAc,IAAI,CAAC;CACtD;AACF"}

package/esm/domain/waitPageActivityEnd.mjs

@@ -0,0 +1,107 @@
+import "./lifeCycle.mjs";
+import { isElementNode } from "../browser/htmlDomUtils.mjs";
+import { createPerformanceObservable } from "../browser/performanceObservable.mjs";
+import { timeStampNow } from "@kubesense/kubesense-js-core/time";
+import { Observable, clearTimeout, matchList, mockable, setTimeout } from "@kubesense/kubesense-browser-core";
+import { monitor } from "@kubesense/kubesense-js-core/monitor";
+const EXCLUDED_MUTATIONS_ATTRIBUTE = "data-kubesense-excluded-activity-mutations";
+/**
+* Wait for the page activity end
+*
+* Detection lifecycle:
+* ```
+*                        Wait page activity end
+*              .-------------------'--------------------.
+*              v                                        v
+*     [Wait for a page activity ]          [Wait for a maximum duration]
+*     [timeout: VALIDATION_DELAY]          [  timeout: maxDuration     ]
+*          /                  \                           |
+*         v                    v                          |
+*  [No page activity]   [Page activity]                   |
+*         |                   |,----------------------.   |
+*         v                   v                       |   |
+*     (Discard)     [Wait for a page activity]        |   |
+*                   [   timeout: END_DELAY   ]        |   |
+*                       /                \            |   |
+*                      v                  v           |   |
+*             [No page activity]    [Page activity]   |   |
+*                      |                 |            |   |
+*                      |                 '------------'   |
+*                      '-----------. ,--------------------'
+*                                   v
+*                                 (End)
+* ```
+*
+* Note: by assuming that maxDuration is greater than VALIDATION_DELAY, we are sure that if the
+* process is still alive after maxDuration, it has been validated.
+*/
+function waitPageActivityEnd(lifeCycle, domMutationObservable, windowOpenObservable, configuration, pageActivityEndCallback, maxDuration) {
+	const pageActivityObservable = mockable(createPageActivityObservable)(lifeCycle, domMutationObservable, windowOpenObservable, configuration);
+	let pageActivityEndTimeoutId;
+	let hasCompleted = false;
+	const validationTimeoutId = setTimeout(monitor(() => complete({ hadActivity: false })), 100);
+	const maxDurationTimeoutId = maxDuration !== void 0 ? setTimeout(monitor(() => complete({
+		hadActivity: true,
+		end: timeStampNow()
+	})), maxDuration) : void 0;
+	const pageActivitySubscription = pageActivityObservable.subscribe(({ isBusy }) => {
+		clearTimeout(validationTimeoutId);
+		clearTimeout(pageActivityEndTimeoutId);
+		const lastChangeTime = timeStampNow();
+		if (!isBusy) pageActivityEndTimeoutId = setTimeout(monitor(() => complete({
+			hadActivity: true,
+			end: lastChangeTime
+		})), 100);
+	});
+	const stop = () => {
+		hasCompleted = true;
+		clearTimeout(validationTimeoutId);
+		clearTimeout(pageActivityEndTimeoutId);
+		clearTimeout(maxDurationTimeoutId);
+		pageActivitySubscription.unsubscribe();
+	};
+	function complete(event) {
+		if (hasCompleted) return;
+		stop();
+		pageActivityEndCallback(event);
+	}
+	return { stop };
+}
+function createPageActivityObservable(lifeCycle, domMutationObservable, windowOpenObservable, configuration) {
+	return new Observable((observable) => {
+		const subscriptions = [];
+		let firstRequestIndex;
+		let pendingRequestsCount = 0;
+		subscriptions.push(domMutationObservable.subscribe((mutations) => {
+			if (!mutations.every(isExcludedMutation)) notifyPageActivity();
+		}), windowOpenObservable.subscribe(notifyPageActivity), createPerformanceObservable({ type: "resource" }).subscribe((entries) => {
+			if (entries.some((entry) => !isExcludedUrl(configuration, entry.name))) notifyPageActivity();
+		}), lifeCycle.subscribe(7, (startEvent) => {
+			if (isExcludedUrl(configuration, startEvent.url)) return;
+			if (firstRequestIndex === void 0) firstRequestIndex = startEvent.requestIndex;
+			pendingRequestsCount += 1;
+			notifyPageActivity();
+		}), lifeCycle.subscribe(8, (request) => {
+			if (isExcludedUrl(configuration, request.url) || firstRequestIndex === void 0 || request.requestIndex < firstRequestIndex) return;
+			pendingRequestsCount -= 1;
+			notifyPageActivity();
+		}));
+		return () => {
+			subscriptions.forEach((s) => s.unsubscribe());
+		};
+		function notifyPageActivity() {
+			observable.notify({ isBusy: pendingRequestsCount > 0 });
+		}
+	});
+}
+function isExcludedUrl(configuration, requestUrl) {
+	return matchList(configuration.excludedActivityUrls, requestUrl);
+}
+function isExcludedMutation(mutation) {
+	const targetElement = mutation.type === "characterData" ? mutation.target.parentElement : mutation.target;
+	return Boolean(targetElement && isElementNode(targetElement) && targetElement.matches(`[data-kubesense-excluded-activity-mutations], [data-kubesense-excluded-activity-mutations] *`));
+}
+//#endregion
+export { EXCLUDED_MUTATIONS_ATTRIBUTE, createPageActivityObservable, waitPageActivityEnd };
+
+//# sourceMappingURL=waitPageActivityEnd.mjs.map

package/esm/domain/waitPageActivityEnd.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"waitPageActivityEnd.mjs","names":[],"sources":["../../src/domain/waitPageActivityEnd.ts"],"sourcesContent":["import type { Subscription, TimeoutId } from '@kubesense/kubesense-browser-core'\nimport { timeStampNow } from '@kubesense/kubesense-js-core/time'\nimport type { TimeStamp } from '@kubesense/kubesense-js-core/time'\nimport { monitor } from '@kubesense/kubesense-js-core/monitor'\nimport { matchList, Observable, setTimeout, clearTimeout, mockable } from '@kubesense/kubesense-browser-core'\nimport { createPerformanceObservable, RumPerformanceEntryType } from '../browser/performanceObservable'\nimport type { RumMutationRecord } from '../browser/domMutationObservable'\nimport { isElementNode } from '../browser/htmlDomUtils'\nimport type { RumConfiguration } from './configuration'\nimport type { LifeCycle } from './lifeCycle'\nimport { LifeCycleEventType } from './lifeCycle'\n\n// Delay to wait for a page activity to validate the tracking process\nexport const PAGE_ACTIVITY_VALIDATION_DELAY = 100\n// Delay to wait after a page activity to end the tracking process\nexport const PAGE_ACTIVITY_END_DELAY = 100\n\nexport const EXCLUDED_MUTATIONS_ATTRIBUTE = 'data-kubesense-excluded-activity-mutations'\n\nexport interface PageActivityEvent {\n  isBusy: boolean\n}\n\nexport type PageActivityEndEvent = { hadActivity: true; end: TimeStamp } | { hadActivity: false }\n\n/**\n * Wait for the page activity end\n *\n * Detection lifecycle:\n * ```\n *                        Wait page activity end\n *              .-------------------'--------------------.\n *              v                                        v\n *     [Wait for a page activity ]          [Wait for a maximum duration]\n *     [timeout: VALIDATION_DELAY]          [  timeout: maxDuration     ]\n *          /                  \\                           |\n *         v                    v                          |\n *  [No page activity]   [Page activity]                   |\n *         |                   |,----------------------.   |\n *         v                   v                       |   |\n *     (Discard)     [Wait for a page activity]        |   |\n *                   [   timeout: END_DELAY   ]        |   |\n *                       /                \\            |   |\n *                      v                  v           |   |\n *             [No page activity]    [Page activity]   |   |\n *                      |                 |            |   |\n *                      |                 '------------'   |\n *                      '-----------. ,--------------------'\n *                                   v\n *                                 (End)\n * ```\n *\n * Note: by assuming that maxDuration is greater than VALIDATION_DELAY, we are sure that if the\n * process is still alive after maxDuration, it has been validated.\n */\nexport function waitPageActivityEnd(\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<RumMutationRecord[]>,\n  windowOpenObservable: Observable<void>,\n  configuration: RumConfiguration,\n  pageActivityEndCallback: (event: PageActivityEndEvent) => void,\n  maxDuration?: number\n) {\n  const pageActivityObservable = mockable(createPageActivityObservable)(\n    lifeCycle,\n    domMutationObservable,\n    windowOpenObservable,\n    configuration\n  )\n\n  let pageActivityEndTimeoutId: TimeoutId\n  let hasCompleted = false\n\n  const validationTimeoutId = setTimeout(\n    monitor(() => complete({ hadActivity: false })),\n    PAGE_ACTIVITY_VALIDATION_DELAY\n  )\n  const maxDurationTimeoutId =\n    maxDuration !== undefined\n      ? setTimeout(\n          monitor(() => complete({ hadActivity: true, end: timeStampNow() })),\n          maxDuration\n        )\n      : undefined\n\n  const pageActivitySubscription = pageActivityObservable.subscribe(({ isBusy }) => {\n    clearTimeout(validationTimeoutId)\n    clearTimeout(pageActivityEndTimeoutId)\n    const lastChangeTime = timeStampNow()\n    if (!isBusy) {\n      pageActivityEndTimeoutId = setTimeout(\n        monitor(() => complete({ hadActivity: true, end: lastChangeTime })),\n        PAGE_ACTIVITY_END_DELAY\n      )\n    }\n  })\n\n  const stop = () => {\n    hasCompleted = true\n    clearTimeout(validationTimeoutId)\n    clearTimeout(pageActivityEndTimeoutId)\n    clearTimeout(maxDurationTimeoutId)\n    pageActivitySubscription.unsubscribe()\n  }\n\n  function complete(event: PageActivityEndEvent) {\n    if (hasCompleted) {\n      return\n    }\n    stop()\n    pageActivityEndCallback(event)\n  }\n  return { stop }\n}\n\nexport function createPageActivityObservable(\n  lifeCycle: LifeCycle,\n  domMutationObservable: Observable<RumMutationRecord[]>,\n  windowOpenObservable: Observable<void>,\n  configuration: RumConfiguration\n): Observable<PageActivityEvent> {\n  return new Observable<PageActivityEvent>((observable) => {\n    const subscriptions: Subscription[] = []\n    let firstRequestIndex: undefined | number\n    let pendingRequestsCount = 0\n\n    subscriptions.push(\n      domMutationObservable.subscribe((mutations) => {\n        if (!mutations.every(isExcludedMutation)) {\n          notifyPageActivity()\n        }\n      }),\n      windowOpenObservable.subscribe(notifyPageActivity),\n      createPerformanceObservable({ type: RumPerformanceEntryType.RESOURCE }).subscribe((entries) => {\n        if (entries.some((entry) => !isExcludedUrl(configuration, entry.name))) {\n          notifyPageActivity()\n        }\n      }),\n      lifeCycle.subscribe(LifeCycleEventType.REQUEST_STARTED, (startEvent) => {\n        if (isExcludedUrl(configuration, startEvent.url)) {\n          return\n        }\n        if (firstRequestIndex === undefined) {\n          firstRequestIndex = startEvent.requestIndex\n        }\n        pendingRequestsCount += 1\n        notifyPageActivity()\n      }),\n      lifeCycle.subscribe(LifeCycleEventType.REQUEST_COMPLETED, (request) => {\n        if (\n          isExcludedUrl(configuration, request.url) ||\n          firstRequestIndex === undefined ||\n          // If the request started before the tracking start, ignore it\n          request.requestIndex < firstRequestIndex\n        ) {\n          return\n        }\n        pendingRequestsCount -= 1\n        notifyPageActivity()\n      })\n    )\n\n    return () => {\n      subscriptions.forEach((s) => s.unsubscribe())\n    }\n\n    function notifyPageActivity() {\n      observable.notify({ isBusy: pendingRequestsCount > 0 })\n    }\n  })\n}\n\nfunction isExcludedUrl(configuration: RumConfiguration, requestUrl: string): boolean {\n  return matchList(configuration.excludedActivityUrls, requestUrl)\n}\n\nfunction isExcludedMutation(mutation: RumMutationRecord): boolean {\n  const targetElement = mutation.type === 'characterData' ? mutation.target.parentElement : mutation.target\n\n  return Boolean(\n    targetElement &&\n    isElementNode(targetElement) &&\n    targetElement.matches(`[${EXCLUDED_MUTATIONS_ATTRIBUTE}], [${EXCLUDED_MUTATIONS_ATTRIBUTE}] *`)\n  )\n}\n"],"mappings":";;;;;;AAiBA,MAAa,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsC5C,SAAgB,oBACd,WACA,uBACA,sBACA,eACA,yBACA,aACA;CACA,MAAM,yBAAyB,SAAS,4BAA4B,CAAC,CACnE,WACA,uBACA,sBACA,aACF;CAEA,IAAI;CACJ,IAAI,eAAe;CAEnB,MAAM,sBAAsB,WAC1B,cAAc,SAAS,EAAE,aAAa,MAAM,CAAC,CAAC,GAAA,GAEhD;CACA,MAAM,uBACJ,gBAAgB,KAAA,IACZ,WACE,cAAc,SAAS;EAAE,aAAa;EAAM,KAAK,aAAa;CAAE,CAAC,CAAC,GAClE,WACF,IACA,KAAA;CAEN,MAAM,2BAA2B,uBAAuB,WAAW,EAAE,aAAa;EAChF,aAAa,mBAAmB;EAChC,aAAa,wBAAwB;EACrC,MAAM,iBAAiB,aAAa;EACpC,IAAI,CAAC,QACH,2BAA2B,WACzB,cAAc,SAAS;GAAE,aAAa;GAAM,KAAK;EAAe,CAAC,CAAC,GAAA,GAEpE;CAEJ,CAAC;CAED,MAAM,aAAa;EACjB,eAAe;EACf,aAAa,mBAAmB;EAChC,aAAa,wBAAwB;EACrC,aAAa,oBAAoB;EACjC,yBAAyB,YAAY;CACvC;CAEA,SAAS,SAAS,OAA6B;EAC7C,IAAI,cACF;EAEF,KAAK;EACL,wBAAwB,KAAK;CAC/B;CACA,OAAO,EAAE,KAAK;AAChB;AAEA,SAAgB,6BACd,WACA,uBACA,sBACA,eAC+B;CAC/B,OAAO,IAAI,YAA+B,eAAe;EACvD,MAAM,gBAAgC,CAAC;EACvC,IAAI;EACJ,IAAI,uBAAuB;EAE3B,cAAc,KACZ,sBAAsB,WAAW,cAAc;GAC7C,IAAI,CAAC,UAAU,MAAM,kBAAkB,GACrC,mBAAmB;EAEvB,CAAC,GACD,qBAAqB,UAAU,kBAAkB,GACjD,4BAA4B,EAAE,MAAA,WAAuC,CAAC,CAAC,CAAC,WAAW,YAAY;GAC7F,IAAI,QAAQ,MAAM,UAAU,CAAC,cAAc,eAAe,MAAM,IAAI,CAAC,GACnE,mBAAmB;EAEvB,CAAC,GACD,UAAU,UAAA,IAA+C,eAAe;GACtE,IAAI,cAAc,eAAe,WAAW,GAAG,GAC7C;GAEF,IAAI,sBAAsB,KAAA,GACxB,oBAAoB,WAAW;GAEjC,wBAAwB;GACxB,mBAAmB;EACrB,CAAC,GACD,UAAU,UAAA,IAAiD,YAAY;GACrE,IACE,cAAc,eAAe,QAAQ,GAAG,KACxC,sBAAsB,KAAA,KAEtB,QAAQ,eAAe,mBAEvB;GAEF,wBAAwB;GACxB,mBAAmB;EACrB,CAAC,CACH;EAEA,aAAa;GACX,cAAc,SAAS,MAAM,EAAE,YAAY,CAAC;EAC9C;EAEA,SAAS,qBAAqB;GAC5B,WAAW,OAAO,EAAE,QAAQ,uBAAuB,EAAE,CAAC;EACxD;CACF,CAAC;AACH;AAEA,SAAS,cAAc,eAAiC,YAA6B;CACnF,OAAO,UAAU,cAAc,sBAAsB,UAAU;AACjE;AAEA,SAAS,mBAAmB,UAAsC;CAChE,MAAM,gBAAgB,SAAS,SAAS,kBAAkB,SAAS,OAAO,gBAAgB,SAAS;CAEnG,OAAO,QACL,iBACA,cAAc,aAAa,KAC3B,cAAc,QAAQ,8FAAwE,CAChG;AACF"}

package/esm/index.mjs

@@ -0,0 +1,23 @@
+import { ActionType, FrustrationType, RumEventType, RumLongTaskEntryType, VitalType } from "./rawRumEvent.types.mjs";
+import { CanvasRecordingQuality, DEFAULT_TRACKED_RESOURCE_HEADERS } from "./domain/configuration/configuration.mjs";
+import { getRoutePath, isRouteRecordable } from "./domain/configuration/sessionReplayRoutes.mjs";
+import "./domain/configuration/index.mjs";
+import { createHooks } from "./domain/hooks.mjs";
+import { getMutationObserverConstructor } from "./browser/domMutationObservable.mjs";
+import { LifeCycle, LifeCycleEventType } from "./domain/lifeCycle.mjs";
+import { startViewHistory } from "./domain/contexts/viewHistory.mjs";
+import { sanitizeIfLongDataUrl } from "./domain/resource/resourceUtils.mjs";
+import { forEachChildNodes, getParentElement, getParentNode, hasChildNodes, isCommentNode, isElementNode, isNodeShadowHost, isNodeShadowRoot, isTextNode } from "./browser/htmlDomUtils.mjs";
+import { RumPerformanceEntryType, supportPerformanceTimingEvent } from "./browser/performanceObservable.mjs";
+import { DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE } from "./domain/action/actionNameConstants.mjs";
+import { STABLE_ATTRIBUTES } from "./domain/getSelectorFromElement.mjs";
+import { CENSORED_IMG_MARK, CENSORED_STRING_MARK, FORM_PRIVATE_TAG_NAMES, NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_ALLOW, PRIVACY_ATTR_VALUE_HIDDEN, PRIVACY_ATTR_VALUE_MASK, PRIVACY_ATTR_VALUE_MASK_UNLESS_ALLOWLISTED, PRIVACY_ATTR_VALUE_MASK_USER_INPUT, PRIVACY_CLASS_PREFIX, TEXT_MASKING_CHAR, getPrivacySelector } from "./domain/privacyConstants.mjs";
+import { censorText, getNodePrivacyLevel, getNodeSelfPrivacyLevel, getTextContent, isAllowlisted, maskDisallowedTextContent, reducePrivacyLevel, shouldIgnoreElement, shouldMaskAttribute, shouldMaskNode } from "./domain/privacy.mjs";
+import { getScrollX, getScrollY } from "./browser/scroll.mjs";
+import { getViewportDimension, initViewportObservable } from "./browser/viewportObservable.mjs";
+import { SessionReplayState, computeSessionReplayState } from "./domain/sessionReplayState.mjs";
+import { startRum } from "./boot/startRum.mjs";
+import { makeRumPublicApi } from "./boot/rumPublicApi.mjs";
+import { getSessionReplayUrl } from "./domain/getSessionReplayUrl.mjs";
+import { createFormDataTransport } from "./transport/formDataTransport.mjs";
+export { ActionType, CENSORED_IMG_MARK, CENSORED_STRING_MARK, CanvasRecordingQuality, DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE, DEFAULT_TRACKED_RESOURCE_HEADERS, FORM_PRIVATE_TAG_NAMES, FrustrationType, LifeCycle, LifeCycleEventType, NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_ALLOW, PRIVACY_ATTR_VALUE_HIDDEN, PRIVACY_ATTR_VALUE_MASK, PRIVACY_ATTR_VALUE_MASK_UNLESS_ALLOWLISTED, PRIVACY_ATTR_VALUE_MASK_USER_INPUT, PRIVACY_CLASS_PREFIX, RumEventType, RumLongTaskEntryType, RumPerformanceEntryType, STABLE_ATTRIBUTES, SessionReplayState, TEXT_MASKING_CHAR, VitalType, censorText, computeSessionReplayState, createFormDataTransport, createHooks, forEachChildNodes, getMutationObserverConstructor, getNodePrivacyLevel, getNodeSelfPrivacyLevel, getParentElement, getParentNode, getPrivacySelector, getRoutePath, getScrollX, getScrollY, getSessionReplayUrl, getTextContent, getViewportDimension, hasChildNodes, initViewportObservable, isAllowlisted, isCommentNode, isElementNode, isNodeShadowHost, isNodeShadowRoot, isRouteRecordable, isTextNode, makeRumPublicApi, maskDisallowedTextContent, reducePrivacyLevel, sanitizeIfLongDataUrl, shouldIgnoreElement, shouldMaskAttribute, shouldMaskNode, startRum, startViewHistory, supportPerformanceTimingEvent };

package/esm/rawRumEvent.types.mjs

@@ -0,0 +1,42 @@
+//#region src/rawRumEvent.types.ts
+const RumEventType = {
+	ACTION: "action",
+	ERROR: "error",
+	LONG_TASK: "long_task",
+	VIEW: "view",
+	VIEW_UPDATE: "view_update",
+	RESOURCE: "resource",
+	VITAL: "vital"
+};
+const RumLongTaskEntryType = {
+	LONG_TASK: "long-task",
+	LONG_ANIMATION_FRAME: "long-animation-frame"
+};
+const ViewLoadingType = {
+	INITIAL_LOAD: "initial_load",
+	ROUTE_CHANGE: "route_change",
+	SESSION_RENEWAL: "session_renewal",
+	BF_CACHE: "bf_cache"
+};
+const ActionType = {
+	CLICK: "click",
+	CUSTOM: "custom",
+	TAP: "tap",
+	SCROLL: "scroll",
+	SWIPE: "swipe",
+	APPLICATION_START: "application_start",
+	BACK: "back"
+};
+const FrustrationType = {
+	RAGE_CLICK: "rage_click",
+	ERROR_CLICK: "error_click",
+	DEAD_CLICK: "dead_click"
+};
+const VitalType = {
+	DURATION: "duration",
+	OPERATION_STEP: "operation_step"
+};
+//#endregion
+export { ActionType, FrustrationType, RumEventType, RumLongTaskEntryType, ViewLoadingType, VitalType };
+
+//# sourceMappingURL=rawRumEvent.types.mjs.map