@atlaskit/react-ufo 3.14.3 → 3.14.5

package/dist/esm/create-payload/utils/get-navigation-metrics.js

@@ -0,0 +1,59 @@
+export default function getNavigationMetrics(type) {
+  if (type !== 'page_load') {
+    return null;
+  }
+  try {
+    var entries = performance.getEntriesByType('navigation');
+    if (entries.length === 0) {
+      return null;
+    }
+    var navigation = entries[0];
+    return {
+      // From https://www.w3.org/TR/resource-timing/
+      redirectStart: Math.round(navigation.redirectStart),
+      redirectEnd: Math.round(navigation.redirectEnd),
+      fetchStart: Math.round(navigation.fetchStart),
+      domainLookupStart: Math.round(navigation.domainLookupStart),
+      domainLookupEnd: Math.round(navigation.domainLookupEnd),
+      connectStart: Math.round(navigation.connectStart),
+      connectEnd: Math.round(navigation.connectEnd),
+      secureConnectionStart: Math.round(navigation.secureConnectionStart),
+      requestStart: Math.round(navigation.requestStart),
+      responseStart: Math.round(navigation.responseStart),
+      responseEnd: Math.round(navigation.responseEnd),
+      encodedBodySize: Math.round(navigation.encodedBodySize),
+      decodedBodySize: Math.round(navigation.decodedBodySize),
+      transferSize: Math.round(navigation.transferSize),
+      // From https://www.w3.org/TR/navigation-timing-2/
+      redirectCount: navigation.redirectCount,
+      type: navigation.type,
+      unloadEventEnd: Math.round(navigation.unloadEventEnd),
+      unloadEventStart: Math.round(navigation.unloadEventStart),
+      workerStart: Math.round(navigation.workerStart),
+      nextHopProtocol: navigation.nextHopProtocol
+
+      // The following properties are ignored because they provided limited value on a modern stack (e.g. the content
+      // is usually rendered and interactive before the dom is fully parsed, don't play well with streamed content...)
+      //   * domComplete
+      //   * domContentLoadedEventEnd
+      //   * domContentLoadedEventStart
+      //   * domInteractive
+      //   * loadEventEnd
+      //   * loadEventStart
+    };
+  } catch (error) {
+    // Return null if there's any error accessing navigation timing
+    return null;
+  }
+}
+
+// Helper function to get navigation metrics in legacy format for backward compatibility
+export function getNavigationMetricsToLegacyFormat(type) {
+  var navigationMetrics = getNavigationMetrics(type);
+  if (!navigationMetrics) {
+    return {};
+  }
+  return {
+    'metrics:navigation': navigationMetrics
+  };
+}

package/dist/esm/create-payload/utils/get-paint-metrics.js

@@ -0,0 +1,119 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+// Type definitions for paint metrics
+
+// Main function returns compact nested format
+export default function getPaintMetrics(_x, _x2) {
+  return _getPaintMetrics.apply(this, arguments);
+}
+
+// Helper function to get paint metrics in legacy colon format for backward compatibility
+function _getPaintMetrics() {
+  _getPaintMetrics = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(type, end) {
+    var paint, paintEntries, lcp;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (!(type !== 'page_load')) {
+            _context.next = 2;
+            break;
+          }
+          return _context.abrupt("return", {});
+        case 2:
+          paint = {};
+          paintEntries = performance.getEntriesByType('paint');
+          paintEntries.forEach(function (entry) {
+            if (entry.name === 'first-paint') {
+              paint.fp = Math.round(entry.startTime);
+            }
+            if (entry.name === 'first-contentful-paint') {
+              paint.fcp = Math.round(entry.startTime);
+            }
+          });
+
+          // Get LCP using PerformanceObserver
+          _context.next = 7;
+          return new Promise(function (resolve) {
+            // Check if we already have LCP entries
+            var existingEntries = performance.getEntriesByType('largest-contentful-paint');
+            var lastEntry = existingEntries.reduce(function (agg, entry) {
+              if (entry.startTime <= end && (agg === null || agg.startTime < entry.startTime)) {
+                return entry;
+              }
+              return agg;
+            }, null);
+            if (lastEntry) {
+              resolve(lastEntry.startTime);
+              return;
+            }
+            var observer = new PerformanceObserver(function (list) {
+              var entries = Array.from(list.getEntries());
+              var lastEntry = entries.reduce(function (agg, entry) {
+                if (entry.startTime <= end && (agg === null || agg.startTime < entry.startTime)) {
+                  return entry;
+                }
+                return agg;
+              }, null);
+              clearTimeout(timeoutId);
+              observer.disconnect();
+              if (lastEntry) {
+                resolve(lastEntry.startTime);
+              } else {
+                resolve(null);
+              }
+            });
+            observer.observe({
+              type: 'largest-contentful-paint',
+              buffered: true
+            });
+            var timeoutId = setTimeout(function () {
+              observer.disconnect();
+              resolve(null);
+            }, 200);
+          });
+        case 7:
+          lcp = _context.sent;
+          if (lcp) {
+            paint.lcp = Math.round(lcp);
+          }
+          return _context.abrupt("return", paint);
+        case 10:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _getPaintMetrics.apply(this, arguments);
+}
+export function getPaintMetricsToLegacyFormat(_x3, _x4) {
+  return _getPaintMetricsToLegacyFormat.apply(this, arguments);
+}
+function _getPaintMetricsToLegacyFormat() {
+  _getPaintMetricsToLegacyFormat = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(type, end) {
+    var paint, legacyFormat;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.next = 2;
+          return getPaintMetrics(type, end);
+        case 2:
+          paint = _context2.sent;
+          legacyFormat = {};
+          if (paint.fp !== undefined) {
+            legacyFormat['metric:fp'] = paint.fp;
+          }
+          if (paint.fcp !== undefined) {
+            legacyFormat['metric:fcp'] = paint.fcp;
+          }
+          if (paint.lcp !== undefined) {
+            legacyFormat['metric:lcp'] = paint.lcp;
+          }
+          return _context2.abrupt("return", legacyFormat);
+        case 8:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _getPaintMetricsToLegacyFormat.apply(this, arguments);
+}

package/dist/esm/create-payload/utils/get-payload-size.js

@@ -0,0 +1,11 @@
+// Reusable TextEncoder instance to avoid creating new instances
+var textEncoder = new TextEncoder();
+export default function getPayloadSize(payload) {
+  // Early return for null/undefined to avoid unnecessary processing
+  if (!payload) {
+    return 0;
+  }
+
+  // Use the reusable encoder instance
+  return Math.round(textEncoder.encode(JSON.stringify(payload)).length / 1024);
+}

package/dist/esm/create-payload/utils/get-react-ufo-payload-version.js

@@ -1,3 +1,4 @@
+export var LATEST_REACT_UFO_PAYLOAD_VERSION = '2.0.0';
 export function getReactUFOPayloadVersion(interactionType, isPostInteractionLog) {
   if (isPostInteractionLog) {
     return '1.0.1';
@@ -5,5 +6,5 @@ export function getReactUFOPayloadVersion(interactionType, isPostInteractionLog)
   if (interactionType !== 'page_load' && interactionType !== 'transition') {
     return '1.0.1';
   }
-  return '2.0.0';
+  return LATEST_REACT_UFO_PAYLOAD_VERSION;
 }

package/dist/esm/create-payload/utils/get-ssr-success.js

@@ -0,0 +1,7 @@
+import * as ssr from '../../ssr';
+export default function getSSRSuccess(type) {
+  if (type !== 'page_load') {
+    return undefined;
+  }
+  return ssr.getSSRSuccess();
+}

package/dist/esm/create-payload/utils/get-ttai.js

@@ -0,0 +1,7 @@
+import getPageVisibilityUpToTTAI from './get-page-visibility-up-to-ttai';
+export default function getTTAI(interaction) {
+  var start = interaction.start,
+    end = interaction.end;
+  var pageVisibilityUpToTTAI = getPageVisibilityUpToTTAI(interaction);
+  return !interaction.abortReason && pageVisibilityUpToTTAI === 'visible' ? Math.round(end - start) : undefined;
+}

package/dist/esm/create-payload/utils/get-tti.js

@@ -0,0 +1,33 @@
+import { findMatchingLegacyMetric } from './find-matching-legacy-metric';
+
+/**
+ * Calculate TTI (Time to Interactive) based on server-side logic
+ * TTI is the time from interaction start to the end of the first matching legacy metric,
+ * or falls back to apdex/UFO end time if no legacy metrics exist
+ */
+export function getTTI(interaction, experienceName) {
+  var _apdex$;
+  var start = interaction.start,
+    end = interaction.end,
+    apdex = interaction.apdex;
+
+  // Find matching legacy metric
+  var matchingLegacyMetric = findMatchingLegacyMetric(interaction, experienceName);
+
+  // Get end times in priority order (following server-side logic)
+  var apdexEndTime = apdex === null || apdex === void 0 || (_apdex$ = apdex[0]) === null || _apdex$ === void 0 ? void 0 : _apdex$.stopTime;
+  var legacyMetricsEndTime = matchingLegacyMetric === null || matchingLegacyMetric === void 0 ? void 0 : matchingLegacyMetric.stop;
+  var ufoEndTime = end;
+  var ttiEndTime;
+  if (matchingLegacyMetric && legacyMetricsEndTime) {
+    // Use legacy metrics end time if we have a matching legacy metric
+    ttiEndTime = legacyMetricsEndTime;
+  } else if (apdexEndTime) {
+    // Fall back to apdex end time if no matching legacy metrics
+    ttiEndTime = apdexEndTime;
+  } else {
+    // Final fallback to UFO end time
+    ttiEndTime = ufoEndTime;
+  }
+  return ttiEndTime ? Math.round(ttiEndTime - start) : undefined;
+}

package/dist/esm/interaction-metrics/index.js

@@ -151,6 +151,29 @@ export function addCustomData(interactionId, labelStack, data) {
     });
   }
 }
+export function addCohortingCustomData(interactionId, key, value) {
+  var interaction = interactions.get(interactionId);
+  if (interaction == null) {
+    return;
+  }
+
+  // Allow null and undefined values
+  if (value === null || value === undefined) {
+    interaction.cohortingCustomData.set(key, value);
+    return;
+  }
+
+  // Validate that the value is a primitive (number, boolean, or string)
+  if (typeof value !== 'number' && typeof value !== 'boolean' && typeof value !== 'string') {
+    return;
+  }
+
+  // Validate string length (max 50 characters)
+  if (typeof value === 'string' && value.length > 50) {
+    return;
+  }
+  interaction.cohortingCustomData.set(key, value);
+}
 export function addCustomTiming(interactionId, labelStack, data) {
   var interaction = interactions.get(interactionId);
   if (interaction != null) {
@@ -744,6 +767,7 @@ export function addNewInteraction(interactionId, ufoName, type, startTime, rate,
     isPreviousInteractionAborted: PreviousInteractionLog.isAborted === true,
     marks: [],
     customData: [],
+    cohortingCustomData: new Map(),
     customTimings: [],
     spans: [],
     requestInfo: [],

package/dist/esm/vc/vc-observer-new/metric-calculator/fy25_03/index.js

@@ -18,6 +18,9 @@ var getConsideredEntryTypes = function getConsideredEntryTypes() {
   if (!fg('platform_ufo_exclude_3p_elements_from_ttvc')) {
     entryTypes.push('mutation:third-party-element');
   }
+  if (fg('platform_ufo_enable_media_for_ttvc_v3')) {
+    entryTypes.push('mutation:media');
+  }
   return entryTypes;
 };
 

package/dist/types/common/common/types.d.ts

@@ -101,6 +101,7 @@ export interface InteractionMetrics {
         labelStack: LabelStack;
         data: CustomData;
     }[];
+    cohortingCustomData: Map<string, number | boolean | string | null | undefined>;
     customTimings: {
         labelStack: LabelStack;
         data: CustomTiming;
@@ -142,7 +143,6 @@ export interface InteractionMetrics {
      *  { name: 'issue-navigator', segmentId: 'xxx' },
      *  { name: 'ui', segmentId: 'xxx' }
      * ]
-     * ```
      */
     responsiveness?: ResponsivenessMetric;
     labelStack: LabelStack | null;

package/dist/types/common/react-ufo-payload-schema.d.ts

@@ -1,7 +1,7 @@
 import { createPayloads } from '../create-payload';
 import { type LabelStack } from '../interaction-context';
 import { VCObserver } from '../vc/vc-observer';
-import type { AbortReasonType, ApdexType, InteractionError, InteractionType, SegmentInfo } from './common/types';
+import type { AbortReasonType, ApdexType, HoldActive, InteractionError, InteractionType, SegmentInfo } from './common/types';
 import type { RevisionPayload } from './vc/types';
 type ExtractPromise<T> = T extends Promise<infer U> ? U : never;
 export type PageVisibility = 'hidden' | 'mixed' | 'visible';
@@ -36,6 +36,11 @@ export type HoldInfo = {
     startTime: number;
     endTime: number;
 };
+export type OptimizedHoldInfo = {
+    labelStack: string;
+    startTime: number;
+    endTime: number;
+};
 export type VCParts = (typeof VCObserver.VCParts)[number];
 export type LeafSegment = {
     n: string;
@@ -107,6 +112,7 @@ export type ReactUFOPayload = {
             };
             'ufo:errors:globalCount': number;
             'ufo:errors:count': number;
+            'ufo:payloadTime'?: number;
             interactionMetrics: {
                 namePrefix: string;
                 segmentPrefix: string;
@@ -134,8 +140,23 @@ export type ReactUFOPayload = {
                 resourceTimings: ResourceTiming[];
                 segments: SegmentInfo[] | RootSegment;
                 reactProfilerTimings: ReactProfilerTiming[];
-                holdInfo: HoldInfo[];
+                holdInfo: OptimizedHoldInfo[];
                 errors: InteractionError[];
+                responsiveness?: {
+                    inputDelay?: number;
+                    experimentalInputToNextPaint?: number;
+                };
+                customData: Array<{
+                    labelStack: LabelStack;
+                    data: any;
+                }>;
+                SSRTimings: Array<{
+                    label: string;
+                    data: any;
+                }>;
+                holdActive: HoldActive[];
+                unknownElementName?: string;
+                unknownElementHierarchy?: string;
             };
             'ufo:vc:rev': RevisionPayload;
             'ufo:vc:ratios': Record<string, number>;

package/dist/types/create-payload/critical-metrics-payload/index.d.ts

@@ -0,0 +1,6 @@
+import type { InteractionMetrics } from '../../common';
+import type { VCResult } from '../../common/vc/types';
+import { CriticalMetricsPayload } from './types';
+export declare function createCriticalMetricsPayloads(interactionId: string, interaction: InteractionMetrics, vcMetrics?: VCResult & {
+    'metric:vc90'?: number | null;
+}): Promise<CriticalMetricsPayload[]>;

package/dist/types/create-payload/critical-metrics-payload/root-metrics.d.ts

@@ -0,0 +1,7 @@
+import type { InteractionMetrics } from '../../common';
+import type { VCResult } from '../../common/vc/types';
+import type { CriticalMetricsPayload } from './types';
+export type { CriticalMetricsPayload, CriticalMetricsPayloadProperties } from './types';
+export declare function createRootCriticalMetricsPayload(interactionId: string, interaction: InteractionMetrics, vcMetrics?: VCResult & {
+    'metric:vc90'?: number | null;
+}): Promise<CriticalMetricsPayload>;

package/dist/types/create-payload/critical-metrics-payload/segment-metrics/create-segment-metrics.d.ts

@@ -0,0 +1,3 @@
+import { InteractionMetrics } from '../../../common';
+import { CriticalMetricsPayload } from '../types';
+export declare function createSegmentMetricsPayloads(interactionId: string, interaction: InteractionMetrics): Promise<CriticalMetricsPayload[]>;

package/dist/types/create-payload/critical-metrics-payload/segment-metrics/get-is-root-segment.d.ts

@@ -0,0 +1,2 @@
+import type { LabelStack } from '../../../interaction-context';
+export default function getIsRootSegment(labelStack: LabelStack): boolean;

package/dist/types/create-payload/critical-metrics-payload/segment-metrics/get-segment-id.d.ts

@@ -0,0 +1,2 @@
+import type { LabelStack } from '../../../interaction-context';
+export default function getSegmentId(labelStack: LabelStack): string | undefined;

package/dist/types/create-payload/critical-metrics-payload/segment-metrics/get-segment-status.d.ts

@@ -0,0 +1,7 @@
+import type { InteractionMetrics, LabelStack } from '../../../common';
+export default function getSegmentStatus(interaction: InteractionMetrics, segment: {
+    labelStack: LabelStack;
+}): {
+    status: string;
+    abortReason: string | undefined;
+};

package/dist/types/create-payload/critical-metrics-payload/segment-metrics/has-segment-failed.d.ts

@@ -0,0 +1,2 @@
+import type { InteractionMetrics } from '../../../common';
+export default function hasSegmentFailed(errors: InteractionMetrics['errors'], segmentId: string): boolean;

package/dist/types/create-payload/critical-metrics-payload/segment-metrics/is-label-stack-under-segment.d.ts

@@ -0,0 +1,2 @@
+import type { LabelStack } from '../../../interaction-context';
+export default function isLabelStackUnderSegment(labelStack: LabelStack, segmentId: string): boolean;

package/dist/types/create-payload/critical-metrics-payload/types.d.ts

@@ -0,0 +1,128 @@
+import type { InteractionType } from '../../common';
+import { NavigationMetrics } from '../utils/get-navigation-metrics';
+export interface CriticalMetricsPayloadProperties {
+    'event:hostname': string;
+    'event:product': string;
+    'event:schema': string;
+    'event:region': string;
+    'event:source': {
+        name: string;
+        version: string;
+    };
+    'experience:key': string;
+    'experience:name': string;
+    browser?: {
+        name: string;
+        version: string;
+    };
+    device?: {
+        cpus?: number;
+        memory?: number;
+    };
+    network?: {
+        effectiveType: string;
+        rtt: number;
+        downlink: number;
+    };
+    time: {
+        localHour: number;
+        localDayOfWeek: number;
+        localTimezoneOffset: number;
+    };
+    metrics: {
+        /**
+         * First Paint
+         */
+        fp?: number;
+        /**
+         * First Contentful Paint
+         */
+        fcp?: number;
+        /**
+         * Largest Contentful Paint
+         */
+        lcp?: number;
+        /**
+         * Time to App Idle
+         */
+        ttai?: number;
+        /**
+         * Time to Interactive
+         * This is legacy metric, that was marked manually by the team
+         */
+        tti?: number;
+        /**
+         * First Meaningful Paint
+         */
+        fmp?: number;
+        /**
+         * Total Blocking Time
+         */
+        tbt?: number;
+        /**
+         * Total Blocking Time Observed
+         */
+        tbtObserved?: number;
+        /**
+         * Cumulative Layout Shift
+         */
+        cls?: number;
+        /**
+         * Time to Visually Complete
+         * Contains array of multiple versions of the metric
+         */
+        ttvc?: {
+            /**
+             * Revision of the metric. e.g. 'fy25.02'
+             */
+            revision: string;
+            /**
+             * Time to Visually Complete 90% of the view port
+             */
+            vc90: number;
+        }[];
+        /**
+         * Earliest Hold Start, for Interaction Response
+         */
+        earliestHoldStart?: number;
+        /**
+         * Input Delay
+         */
+        inputDelay?: number;
+        /**
+         * Input to Next Paint
+         */
+        inp?: number;
+        /**
+         * Navigation metrics, only valid for initial page load from:
+         *  https://www.w3.org/TR/resource-timing/
+         *  https://www.w3.org/TR/navigation-timing-2/
+         */
+        navigation?: NavigationMetrics;
+    };
+    interactionId: string;
+    type: InteractionType | 'page_segment_load';
+    rate: number;
+    routeName?: string;
+    start: number;
+    end: number;
+    status: string;
+    abortReason?: string;
+    previousInteractionName?: string;
+    isPreviousInteractionAborted?: boolean;
+    abortedByInteractionName?: string;
+    pageVisibilityAtTTAI?: string;
+    pageVisibilityAtTTI?: string;
+    errorCount: number;
+    cohortingCustomData?: Record<string, number | boolean | string | null | undefined>;
+}
+export interface CriticalMetricsPayload {
+    actionSubject: 'experience';
+    action: 'measured';
+    eventType: 'operational';
+    source: 'measured';
+    tags: ['observability'];
+    attributes: {
+        properties: CriticalMetricsPayloadProperties;
+    };
+}