@atlaskit/react-ufo 1.1.0 → 2.0.1

package/dist/esm/create-post-interaction-log-payload/index.js

@@ -0,0 +1,200 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { REACT_UFO_VERSION } from '../common/constants';
+import { getConfig } from '../config';
+import { isSegmentLabel, sanitizeUfoName } from '../create-payload/common/utils';
+import { getPageVisibilityState } from '../hidden-timing';
+function getParentStack(labelStack) {
+  if (!labelStack || labelStack.length <= 1) {
+    return null;
+  }
+  return labelStack.slice(0, labelStack.length - 1);
+}
+function getSegmentId(labelStack) {
+  if (!labelStack) {
+    return null;
+  }
+  var leafLabelStack = labelStack[labelStack.length - 1];
+  if (isSegmentLabel(leafLabelStack)) {
+    return leafLabelStack.segmentId;
+  }
+  var parentStack = getParentStack(labelStack);
+  if (!parentStack) {
+    return null;
+  }
+  return getSegmentId(parentStack);
+}
+function getParentSegmentId(labelStack) {
+  return getSegmentId(getParentStack(labelStack));
+}
+
+/**
+ * Whenever a render happen, all parent segment have timing reported
+ * This method tries to reduce that noise
+ */
+function removeCascadingParentTimingReport(reactProfilerTimings) {
+  var timingIndex = new Map();
+  reactProfilerTimings.forEach(function (timing) {
+    var segmentId = getSegmentId(timing.labelStack);
+    if (segmentId) {
+      var _timingIndex$get;
+      var timingArray = (_timingIndex$get = timingIndex.get(segmentId)) !== null && _timingIndex$get !== void 0 ? _timingIndex$get : [];
+      timingIndex.set(segmentId, timingArray);
+      timingArray.push(timing);
+    }
+  });
+  reactProfilerTimings.forEach(function (timing) {
+    var parentSegmentId = getParentSegmentId(timing.labelStack);
+    if (parentSegmentId) {
+      var parentTimings = timingIndex.get(parentSegmentId);
+      var filteredParentTimings = parentTimings === null || parentTimings === void 0 ? void 0 : parentTimings.filter(function (parentTiming) {
+        if (parentTiming.startTime === timing.startTime && parentTiming.actualDuration === timing.actualDuration) {
+          return false;
+        }
+        return true;
+      });
+      if (filteredParentTimings) {
+        timingIndex.set(parentSegmentId, filteredParentTimings);
+      } else {
+        timingIndex.delete(parentSegmentId);
+      }
+    }
+  });
+  return _toConsumableArray(timingIndex.values()).flatMap(function (v) {
+    return v;
+  });
+}
+function transformReactProfilerTimings(reactProfilerTimings) {
+  var filtered = removeCascadingParentTimingReport(reactProfilerTimings !== null && reactProfilerTimings !== void 0 ? reactProfilerTimings : []);
+  var reactProfilerTimingsMap = filtered.reduce(function (result, _ref) {
+    var labelStack = _ref.labelStack,
+      startTime = _ref.startTime,
+      commitTime = _ref.commitTime,
+      actualDuration = _ref.actualDuration,
+      type = _ref.type;
+    if (labelStack && type !== 'nested-update') {
+      var label = labelStack.map(function (ls) {
+        return ls.name;
+      }).join('/');
+      var start = Math.round(startTime);
+      var end = Math.round(commitTime);
+      var timing = result.get(label) || {
+        labelStack: label,
+        startTime: start,
+        endTime: end,
+        mountCount: 0,
+        rerenderCount: 1,
+        renderDuration: 0
+      };
+      if (start < timing.startTime) {
+        timing.startTime = Math.round(start);
+      }
+      if (end > timing.endTime) {
+        timing.endTime = Math.round(end);
+      }
+      if (type === 'mount') {
+        timing.mountCount += 1;
+      }
+      if (type === 'update') {
+        timing.rerenderCount += 1;
+      }
+      timing.renderDuration += Math.round(actualDuration);
+      result.set(label, timing);
+    }
+    return result;
+  }, new Map());
+  return _toConsumableArray(reactProfilerTimingsMap.values());
+}
+export default function createPostInteractionLogPayload(_ref2) {
+  var _window$location;
+  var lastInteractionFinish = _ref2.lastInteractionFinish,
+    reactProfilerTimings = _ref2.reactProfilerTimings,
+    lastInteractionFinishVCResult = _ref2.lastInteractionFinishVCResult,
+    postInteractionFinishVCResult = _ref2.postInteractionFinishVCResult;
+  var config = getConfig();
+  if (!config) {
+    throw Error('UFO Configuration not provided');
+  }
+  var ufoName = sanitizeUfoName(lastInteractionFinish.ufoName);
+  var pageVisibilityState = getPageVisibilityState(lastInteractionFinish.start, lastInteractionFinish.end);
+  if (pageVisibilityState !== 'visible') {
+    return null;
+  }
+  var maxEndTimeFromProfiler = reactProfilerTimings ? Math.max.apply(Math, _toConsumableArray(reactProfilerTimings.map(function (t) {
+    return t.commitTime;
+  }))) : lastInteractionFinish.end;
+  var revisedEndTime = Math.round(maxEndTimeFromProfiler);
+  var revisedTtai = Math.round(maxEndTimeFromProfiler - lastInteractionFinish.start);
+  var lastInteractionFinishStart = Math.round(lastInteractionFinish.start);
+  var lastInteractionFinishEnd = Math.round(lastInteractionFinish.end);
+  var lastInteractionFinishTTAI = Math.round(lastInteractionFinish.end - lastInteractionFinish.start);
+  var lastInteractionFinishVC90 = null;
+  if (lastInteractionFinishVCResult !== null && lastInteractionFinishVCResult !== void 0 && lastInteractionFinishVCResult['ufo:vc:state']) {
+    var _lastInteractionFinis;
+    var lastInteractionFinishVCMetrics = lastInteractionFinishVCResult === null || lastInteractionFinishVCResult === void 0 ? void 0 : lastInteractionFinishVCResult['metrics:vc'];
+    lastInteractionFinishVC90 = (_lastInteractionFinis = lastInteractionFinishVCMetrics[90]) !== null && _lastInteractionFinis !== void 0 ? _lastInteractionFinis : null;
+  }
+  var postInteractionFinishVCRatios = {};
+  var revisedVC90 = null;
+  var postInteractionFinishVCUpdates = [];
+  if (postInteractionFinishVCResult !== null && postInteractionFinishVCResult !== void 0 && postInteractionFinishVCResult['ufo:vc:state']) {
+    postInteractionFinishVCRatios = postInteractionFinishVCResult === null || postInteractionFinishVCResult === void 0 ? void 0 : postInteractionFinishVCResult['ufo:vc:ratios'];
+    postInteractionFinishVCUpdates = postInteractionFinishVCResult === null || postInteractionFinishVCResult === void 0 ? void 0 : postInteractionFinishVCResult['ufo:vc:updates'];
+    var postInteractionFinishVCMetrics = postInteractionFinishVCResult === null || postInteractionFinishVCResult === void 0 ? void 0 : postInteractionFinishVCResult['metrics:vc'];
+    if (typeof lastInteractionFinishVC90 === 'number') {
+      var _postInteractionFinis;
+      revisedVC90 = (_postInteractionFinis = postInteractionFinishVCMetrics[90]) !== null && _postInteractionFinis !== void 0 ? _postInteractionFinis : null;
+    }
+  }
+  var lateMutations = postInteractionFinishVCUpdates.filter(function (entry) {
+    return entry.time > lastInteractionFinish.end;
+  }).flatMap(function (_ref3) {
+    var time = _ref3.time,
+      elements = _ref3.elements;
+    return Array.from(new Set(elements)).map(function (element) {
+      return {
+        time: time,
+        element: element,
+        viewportHeatmapPercentage: postInteractionFinishVCRatios[element]
+      };
+    });
+  });
+  return {
+    actionSubject: 'experience',
+    action: 'measured',
+    eventType: 'operational',
+    source: 'measured',
+    tags: ['observability'],
+    attributes: {
+      properties: {
+        // basic
+        'event:hostname': ((_window$location = window.location) === null || _window$location === void 0 ? void 0 : _window$location.hostname) || 'unknown',
+        'event:product': config.product,
+        'event:schema': '1.0.0',
+        'event:source': {
+          name: 'react-ufo/web',
+          version: REACT_UFO_VERSION,
+          payloadSource: 'platform'
+        },
+        'event:region': config.region || 'unknown',
+        'experience:key': 'custom.post-interaction-logs',
+        postInteractionLog: {
+          lastInteractionFinish: _objectSpread(_objectSpread({}, lastInteractionFinish), {}, {
+            ufoName: ufoName,
+            start: lastInteractionFinishStart,
+            end: lastInteractionFinishEnd,
+            ttai: lastInteractionFinishTTAI,
+            vc90: lastInteractionFinishVC90
+          }),
+          revisedEndTime: revisedEndTime,
+          revisedTtai: revisedTtai,
+          revisedVC90: revisedVC90,
+          lateMutations: lateMutations,
+          reactProfilerTimings: transformReactProfilerTimings(reactProfilerTimings)
+        }
+      }
+    }
+  };
+}

package/dist/esm/custom-data/index.js

@@ -0,0 +1,23 @@
+import { useContext, useMemo } from 'react';
+import UFOInteractionContext from '../interaction-context';
+import { getInteractionId } from '../interaction-id-context';
+import { addCustomData } from '../interaction-metrics';
+export default function UFOCustomData(_ref) {
+  var data = _ref.data;
+  var interactionContext = useContext(UFOInteractionContext);
+  useMemo(function () {
+    if (!interactionContext) {
+      return;
+    }
+    interactionContext.addCustomData(data);
+  }, [data, interactionContext]);
+  return null;
+}
+export function addUFOCustomData(data) {
+  var interactionId = getInteractionId();
+  var currentInteractionId = interactionId.current;
+  if (!currentInteractionId) {
+    return;
+  }
+  addCustomData(currentInteractionId, [], data);
+}

package/dist/esm/custom-data/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/custom-mark/index.js

@@ -0,0 +1,36 @@
+import { useContext, useMemo } from 'react';
+import UFOInteractionContext from '../interaction-context';
+import { getInteractionId } from '../interaction-id-context';
+import { addMark } from '../interaction-metrics';
+export default function UFOCustomMark(_ref) {
+  var name = _ref.name,
+    timestamp = _ref.timestamp;
+  var interactionContext = useContext(UFOInteractionContext);
+  useMemo(function () {
+    if (interactionContext != null) {
+      interactionContext.addMark(name, timestamp);
+    }
+  }, [interactionContext, name, timestamp]);
+  return null;
+}
+export function UFOCustomMarks(_ref2) {
+  var data = _ref2.data;
+  var interactionContext = useContext(UFOInteractionContext);
+  useMemo(function () {
+    if (interactionContext != null && data != null) {
+      Object.keys(data).forEach(function (i) {
+        interactionContext.addMark(i, data[i]);
+      });
+    }
+  }, [data, interactionContext]);
+  return null;
+}
+export function addUFOCustomMark(name, timestamp) {
+  var interactionId = getInteractionId();
+  var currentInteractionId = interactionId.current;
+  if (!currentInteractionId) {
+    return;
+  }
+  var time = timestamp || performance.now();
+  addMark(currentInteractionId, 'custom', name, [], time);
+}

package/dist/esm/custom-spans/index.js

@@ -0,0 +1,8 @@
+import { addSpanToAll } from '../interaction-metrics';
+export function addCustomSpans(name, start) {
+  var end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : performance.now();
+  var size = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  addSpanToAll('custom', name, [{
+    name: 'custom'
+  }], start, end, size);
+}

package/dist/esm/custom-timings/index.js

@@ -0,0 +1,56 @@
+import { useContext, useMemo } from 'react';
+import UFOInteractionContext from '../interaction-context';
+import { getInteractionId } from '../interaction-id-context';
+import { addCustomTiming, getCurrentInteractionType } from '../interaction-metrics';
+export function getBm3Timings(marks, timingConfigs) {
+  var bm3Timings = {};
+  if (!marks || !timingConfigs) {
+    return bm3Timings;
+  }
+  timingConfigs.forEach(function (item) {
+    if (!item.startMark || !item.endMark) {
+      return;
+    }
+    var startTime = marks[item.startMark];
+    if (!startTime) {
+      return;
+    }
+    var endTime = marks[item.endMark];
+    if (!endTime) {
+      return;
+    }
+    bm3Timings[item.key] = {
+      startTime: startTime,
+      endTime: endTime
+    };
+  });
+  return bm3Timings;
+}
+export function UFOBM3TimingsToUFO(_ref) {
+  var marks = _ref.marks,
+    timings = _ref.timings;
+  var interactionContext = useContext(UFOInteractionContext);
+  var interactionId = getInteractionId().current;
+  useMemo(function () {
+    if (interactionContext != null && interactionId != null && marks != null && timings != null) {
+      var interactionType = getCurrentInteractionType(interactionId);
+      if (interactionType === 'press') {
+        return;
+      }
+      var bm3Timings = getBm3Timings(marks, timings);
+      interactionContext.addCustomTimings(bm3Timings);
+    }
+  }, [interactionContext, interactionId, marks, timings]);
+  return null;
+}
+export function addBM3TimingsToUFO(marks, timingsConfig) {
+  var interactionId = getInteractionId().current;
+  if (interactionId) {
+    var interactionType = getCurrentInteractionType(interactionId);
+    if (interactionType === 'press') {
+      return;
+    }
+    var bm3Timings = getBm3Timings(marks, timingsConfig);
+    addCustomTiming(interactionId, [], bm3Timings);
+  }
+}

package/dist/esm/experience-trace-id-context/index.js

@@ -0,0 +1,34 @@
+import { makeTraceHttpRequestHeaders } from './utils/make-trace-http-request-headers';
+var state = {
+  context: null
+};
+export var generateSpanId = function generateSpanId() {
+  return Array.from(new Array(16), function () {
+    return Math.floor(Math.random() * 16).toString(16);
+  }).join('');
+};
+export var setInteractionActiveTrace = function setInteractionActiveTrace(interactionId, experienceType) {
+  setActiveTrace(interactionId.replace(/-/g, ''), generateSpanId(), experienceType);
+};
+export var setActiveTrace = function setActiveTrace(traceId, spanId, type) {
+  state.context = {
+    traceId: traceId,
+    spanId: spanId,
+    type: type
+  };
+};
+export var getActiveTrace = function getActiveTrace() {
+  return state.context || undefined;
+};
+export var clearActiveTrace = function clearActiveTrace() {
+  state.context = null;
+};
+export var getActiveTraceHttpRequestHeaders = function getActiveTraceHttpRequestHeaders(_url) {
+  if (state.context === null) {
+    return null;
+  }
+  var _state$context = state.context,
+    traceId = _state$context.traceId,
+    spanId = _state$context.spanId;
+  return makeTraceHttpRequestHeaders(traceId, spanId);
+};

package/dist/esm/experience-trace-id-context/utils/make-trace-http-request-headers/index.js

@@ -0,0 +1,6 @@
+export var makeTraceHttpRequestHeaders = function makeTraceHttpRequestHeaders(traceId, spanId) {
+  return {
+    'X-B3-TraceId': traceId,
+    'X-B3-SpanId': spanId
+  };
+};

package/dist/esm/feature-flags-accessed/common/constants.js

@@ -0,0 +1 @@
+export var NON_BOOLEAN_VALUE = 'non_boolean';

package/dist/esm/feature-flags-accessed/common/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/feature-flags-accessed/common/utils/index.js

@@ -0,0 +1,31 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import { NON_BOOLEAN_VALUE } from '../constants';
+var startsAsObject = function startsAsObject(value) {
+  try {
+    if (value.charAt(0) === '{') {
+      return true;
+    }
+  } catch (e) {
+    return false;
+  }
+  return false;
+};
+var isObject = function isObject(value) {
+  return value && _typeof(value) === 'object' && value.constructor === Object;
+};
+var isString = function isString(input) {
+  var result;
+  try {
+    result = typeof input === 'string' || input instanceof String;
+  } catch (err) {
+    // swallow any errors
+    result = false;
+  }
+  return result;
+};
+export var shouldRedactValue = function shouldRedactValue(value) {
+  return isString(value) && startsAsObject(value) || isObject(value);
+};
+export var redactValue = function redactValue(featureFlagValue) {
+  return shouldRedactValue(featureFlagValue) ? NON_BOOLEAN_VALUE : featureFlagValue;
+};

package/dist/esm/feature-flags-accessed/index.js

@@ -0,0 +1,21 @@
+import { redactValue } from './common/utils';
+export { redactValue } from './common/utils';
+export var allFeatureFlagsAccessed = new Map();
+export var currentFeatureFlagsAccessed = new Map();
+
+/**
+ * Used for tracking accessed feature flags in "@atlassian/jira-feature-flagging".
+ * */
+export var addFeatureFlagAccessed = function addFeatureFlagAccessed(featureFlagName, featureFlagValue) {
+  try {
+    // Inform Criterion about FF being accessed
+    if (globalThis.__CRITERION__ && typeof globalThis.__CRITERION__.addFeatureFlagAccessed === 'function') {
+      globalThis.__CRITERION__.addFeatureFlagAccessed(featureFlagName, featureFlagValue);
+    }
+  } catch (_e) {
+    // ignore the criterion error
+  }
+  var value = redactValue(featureFlagValue);
+  allFeatureFlagsAccessed.set(featureFlagName, value);
+  currentFeatureFlagsAccessed.set(featureFlagName, value);
+};

package/dist/esm/generate-id/index.js

@@ -0,0 +1,6 @@
+var id = 0;
+
+/** Get a new string id each time it's called */
+export default function generateId() {
+  return String(id++);
+}

package/dist/esm/global-error-handler/index.js

@@ -0,0 +1,67 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import { bind } from 'bind-event-listener';
+var shouldInitilizeGlobalErrorHandler = true;
+var errors = [];
+var push = function push(name, labelStack, errorType, errorMessage, errorStack) {
+  errors.push({
+    name: name,
+    labelStack: labelStack,
+    errorType: errorType,
+    errorMessage: errorMessage,
+    errorStack: errorStack
+  });
+};
+export var sinkErrorHandler = function sinkErrorHandler(sinkFunc) {
+  push = sinkFunc;
+  errors.forEach(function (e) {
+    sinkFunc(e.name, e.labelStack, e.errorType, e.errorMessage, e.errorStack);
+  });
+  errors.length = 0;
+};
+var handleError = function handleError(e) {
+  var _e$error;
+  if (((_e$error = e.error) === null || _e$error === void 0 ? void 0 : _e$error.UFOhasCaught) === undefined) {
+    try {
+      if (e.error instanceof Error) {
+        push('GlobalErrorHandler', null, e.error.name, e.error.message, e.error.stack);
+      } else if (e.error) {
+        var hint = JSON.stringify(e.error).slice(0, 50);
+        push('GlobalErrorHandler', null, '', "Non error object thrown: ".concat(hint), undefined);
+      } else if (e.message !== undefined) {
+        var _hint = e.message.slice(0, 50);
+        push('GlobalErrorHandler', null, '', "Non error object thrown: ".concat(_hint), undefined);
+      }
+      if (e.error && _typeof(e.error) === 'object') {
+        e.error.UFOhasCaught = true;
+      }
+      // eslint-disable-next-line no-empty
+    } catch (e) {}
+  }
+};
+var handlePromiseRejection = function handlePromiseRejection(e) {
+  if (e.reason instanceof Error) {
+    push('GlobalErrorHandler', null, e.reason.name, e.reason.message, e.reason.stack);
+  } else if (e.reason) {
+    try {
+      var hint = JSON.stringify(e.reason).slice(0, 50);
+      push('GlobalErrorHandler', null, '', "Non error object thrown: ".concat(hint), undefined);
+      // eslint-disable-next-line no-empty
+    } catch (e) {}
+  }
+};
+var setupUFOGlobalErrorHandler = function setupUFOGlobalErrorHandler() {
+  if (shouldInitilizeGlobalErrorHandler) {
+    bind(window, {
+      type: 'error',
+      listener: function listener(e) {
+        return handleError(e);
+      }
+    });
+    bind(window, {
+      type: 'unhandledrejection',
+      listener: handlePromiseRejection
+    });
+    shouldInitilizeGlobalErrorHandler = false;
+  }
+};
+export default setupUFOGlobalErrorHandler;

package/dist/esm/hidden-timing/index.js

@@ -0,0 +1,87 @@
+import { bind } from 'bind-event-listener';
+var timings = [];
+var wasHiddenFlag;
+var setupFlag = false;
+function isPageHidden() {
+  if ('visibilityState' in document) {
+    return document.visibilityState === 'hidden';
+  } else {
+    // @ts-expect-error - Property 'hidden' does not exist on type 'never'.
+    return document.hidden;
+  }
+}
+var SIZE = 50;
+var insertIndex = 0;
+function pushHidden(isPageHiddenFlag, time) {
+  timings[insertIndex] = {
+    time: time !== null && time !== void 0 ? time : performance.now(),
+    hidden: isPageHiddenFlag
+  };
+  insertIndex = (insertIndex + 1) % SIZE;
+  wasHiddenFlag = isPageHiddenFlag;
+}
+function handleChange() {
+  var isPageHiddenFlag = isPageHidden();
+  if (isPageHiddenFlag) {
+    if (!wasHiddenFlag) {
+      pushHidden(isPageHiddenFlag);
+    }
+    wasHiddenFlag = true;
+  } else {
+    if (wasHiddenFlag) {
+      pushHidden(isPageHiddenFlag);
+    }
+    wasHiddenFlag = false;
+  }
+}
+function setup() {
+  bind(window, {
+    type: 'pageshow',
+    listener: handleChange
+  });
+  bind(window, {
+    type: 'pagehide',
+    listener: handleChange
+  });
+  bind(document, {
+    type: 'visibilitychange',
+    listener: handleChange
+  });
+}
+export function setupHiddenTimingCapture() {
+  if (!setupFlag) {
+    var isPageHiddenFlag = isPageHidden();
+    pushHidden(isPageHiddenFlag, 0);
+    setup();
+    setupFlag = true;
+  }
+}
+export function getPageVisibilityState(start, end) {
+  // Desirable default value is visible
+  if (timings.length === 0) {
+    return 'visible';
+  }
+  var currentSize = timings.length;
+  var hiddenState = 'mixed';
+  var startIdx = insertIndex;
+  var endIdx = insertIndex;
+
+  // currentSize is capped at SIZE.
+  for (var i = 0; i < currentSize; i++) {
+    var tmpIdx = (insertIndex + i) % currentSize;
+    if (timings[tmpIdx].time <= end) {
+      endIdx = tmpIdx;
+      if (timings[tmpIdx].time <= start) {
+        startIdx = tmpIdx;
+      }
+    }
+  }
+  if (endIdx - startIdx === 0) {
+    if (timings[startIdx].hidden) {
+      hiddenState = 'hidden';
+    } else {
+      hiddenState = 'visible';
+    }
+  }
+  return hiddenState;
+}

package/dist/esm/initial-page-load-extra-timing/index.js

@@ -0,0 +1,42 @@
+var timings = [];
+export function addTimingFromPerformanceMark(name, startMark, stopMark) {
+  var cleanStart = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var cleanStop = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  timings.push({
+    name: name,
+    startMark: startMark,
+    stopMark: stopMark,
+    cleanStart: cleanStart,
+    cleanStop: cleanStop
+  });
+}
+export function getTimings() {
+  var reportedTimingsObj = {};
+  timings.forEach(function (_ref) {
+    var name = _ref.name,
+      startMark = _ref.startMark,
+      stopMark = _ref.stopMark,
+      cleanStart = _ref.cleanStart,
+      cleanStop = _ref.cleanStop;
+    var startEntryList = performance.getEntriesByName(startMark);
+    var stopEntryList = performance.getEntriesByName(stopMark);
+    if ((startEntryList === null || startEntryList === void 0 ? void 0 : startEntryList.length) > 0 && (stopEntryList === null || stopEntryList === void 0 ? void 0 : stopEntryList.length) > 0) {
+      var startEntry = startEntryList[startEntryList.length - 1];
+      var stopEntry = stopEntryList[stopEntryList.length - 1];
+      var startTime = startEntry.startTime;
+      var duration = stopEntry.startTime - startTime;
+      var timing = {
+        startTime: Math.round(startTime),
+        duration: Math.round(duration)
+      };
+      reportedTimingsObj[name] = timing;
+    }
+    if (cleanStart) {
+      performance.clearMarks(startMark);
+    }
+    if (cleanStop) {
+      performance.clearMarks(stopMark);
+    }
+  });
+  return reportedTimingsObj;
+}

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

@@ -0,0 +1,6 @@
+import { useContext } from 'react';
+import InteractionContext from '@atlaskit/interaction-context';
+export default InteractionContext;
+export function useInteractionContext() {
+  return useContext(InteractionContext);
+}

package/dist/esm/interaction-id-context/index.js

@@ -0,0 +1,22 @@
+import { createContext } from 'react';
+
+// Same structure as react's useRef.
+// This allows modals to use a ref to scope their value
+// const id = useRef(null);
+// <InteractionIDContext.Provider value={id}>...<
+
+// The default InteractionID object is a global singleton
+// It's the one that holds the root value used in routing,
+// and is overwritten when we have new interactions start.
+export var DefaultInteractionID = {
+  current: null
+};
+
+// We use a context to allow modals to have their own lifecycle
+export default /*#__PURE__*/createContext(DefaultInteractionID);
+export var getInteractionId = function getInteractionId() {
+  return DefaultInteractionID;
+};
+export var useInteractionId = function useInteractionId() {
+  return DefaultInteractionID;
+};

package/dist/esm/interaction-metrics/common/constants.js

@@ -0,0 +1,2 @@
+var interactions = new Map();
+export default interactions;