@atlaskit/react-ufo 3.1.4 → 3.3.0

package/dist/esm/vc/vc-observer-new/metric-calculator/utils/get-viewport-height.js

@@ -0,0 +1,10 @@
+export default function getViewportHeight() {
+  var document = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window.document;
+  var documentHeight;
+  try {
+    documentHeight = document.documentElement.clientHeight || 0;
+  } catch (e) {
+    documentHeight = 0;
+  }
+  return Math.max(documentHeight, window.innerHeight || 0);
+}

package/dist/esm/vc/vc-observer-new/metric-calculator/utils/get-viewport-width.js

@@ -0,0 +1,10 @@
+export default function getViewportWidth() {
+  var document = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window.document;
+  var documentWidth;
+  try {
+    documentWidth = document.documentElement.clientWidth || 0;
+  } catch (e) {
+    documentWidth = 0;
+  }
+  return Math.max(documentWidth, window.innerWidth || 0);
+}

package/dist/esm/vc/vc-observer-new/metric-calculator/utils/is-viewport-entry-data.js

@@ -0,0 +1,10 @@
+export default function isViewportEntryData(data) {
+  if (data) {
+    var hasElementName = typeof data.elementName === 'string';
+    var hasRect = typeof data.rect !== 'undefined';
+    if (hasRect && hasElementName) {
+      return true;
+    }
+  }
+  return false;
+}

package/dist/esm/vc/vc-observer-new/metric-calculator/utils/task-yield.js

@@ -0,0 +1,38 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+// See https://developer.mozilla.org/en-US/docs/Web/API/Prioritized_Task_Scheduling_API
+export default function taskYield() {
+  return _taskYield.apply(this, arguments);
+}
+function _taskYield() {
+  _taskYield = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var resolve, p;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (!('scheduler' in globalThis &&
+          // @ts-ignore
+          'yield' in globalThis.scheduler)) {
+            _context.next = 4;
+            break;
+          }
+          _context.next = 3;
+          return scheduler.yield();
+        case 3:
+          return _context.abrupt("return");
+        case 4:
+          resolve = function resolve() {};
+          p = new Promise(function (a) {
+            resolve = a;
+          });
+          setTimeout(resolve, 0);
+          _context.next = 9;
+          return p;
+        case 9:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _taskYield.apply(this, arguments);
+}

package/dist/esm/vc/vc-observer-new/types.js

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

package/dist/esm/vc/vc-observer-new/viewport-observer/index.js

@@ -0,0 +1,189 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { isContainedWithinMediaWrapper } from '../../vc-observer/media-wrapper/vc-utils';
+import { createIntersectionObserver } from './intersection-observer';
+import createMutationObserver from './mutation-observer';
+import createPerformanceObserver from './performance-observer';
+function isElementVisible(element) {
+  if (!(element instanceof HTMLElement)) {
+    return true;
+  }
+  try {
+    var visible = element.checkVisibility({
+      // @ts-expect-error
+      visibilityProperty: true
+    });
+    return visible;
+  } catch (e) {
+    // there is no support for checkVisibility
+    return true;
+  }
+}
+function sameRectSize(a, b) {
+  if (!a || !b) {
+    return false;
+  }
+  return a.width === b.width && a.height === b.height;
+}
+function sameRectDimensions(a, b) {
+  if (!a || !b) {
+    return false;
+  }
+  return a.width === b.width && a.height === b.height && a.x === b.x && a.y === b.y;
+}
+var ViewportObserver = /*#__PURE__*/function () {
+  function ViewportObserver(_ref) {
+    var _this = this;
+    var onChange = _ref.onChange;
+    _classCallCheck(this, ViewportObserver);
+    this.mapVisibleNodeRects = new WeakMap();
+    this.intersectionObserver = createIntersectionObserver({
+      onEntry: function onEntry(_ref2) {
+        var target = _ref2.target,
+          rect = _ref2.rect,
+          time = _ref2.time,
+          type = _ref2.type,
+          mutationData = _ref2.mutationData;
+        var visible = isElementVisible(target);
+        var lastElementRect = _this.mapVisibleNodeRects.get(target);
+        _this.mapVisibleNodeRects.set(target, rect);
+        onChange({
+          time: time,
+          type: type,
+          elementRef: new WeakRef(target),
+          visible: visible,
+          rect: rect,
+          previousRect: lastElementRect,
+          mutationData: mutationData
+        });
+      }
+    });
+    this.mutationObserver = createMutationObserver({
+      onChildListMutation: function onChildListMutation(_ref3) {
+        var _removedNodes$map;
+        var addedNodes = _ref3.addedNodes,
+          removedNodes = _ref3.removedNodes;
+        var removedNodeRects = (_removedNodes$map = removedNodes === null || removedNodes === void 0 ? void 0 : removedNodes.map(function (n) {
+          return _this.mapVisibleNodeRects.get(n);
+        })) !== null && _removedNodes$map !== void 0 ? _removedNodes$map : [];
+        addedNodes.forEach(function (addedNode) {
+          var _this$intersectionObs3;
+          // for (const elem of addedNode.querySelectorAll('*')) {
+          // 	this.intersectionObserver?.watchAndTag(elem, 'mutation:child-element');
+          // }
+
+          var sameDeletedNode = removedNodes.find(function (n) {
+            return n.isEqualNode(addedNode);
+          });
+          if (sameDeletedNode) {
+            var _this$intersectionObs;
+            (_this$intersectionObs = _this.intersectionObserver) === null || _this$intersectionObs === void 0 || _this$intersectionObs.watchAndTag(addedNode, 'mutation:remount');
+            return;
+          }
+          if (isContainedWithinMediaWrapper(addedNode)) {
+            var _this$intersectionObs2;
+            (_this$intersectionObs2 = _this.intersectionObserver) === null || _this$intersectionObs2 === void 0 || _this$intersectionObs2.watchAndTag(addedNode, 'mutation:media');
+            return;
+          }
+          (_this$intersectionObs3 = _this.intersectionObserver) === null || _this$intersectionObs3 === void 0 || _this$intersectionObs3.watchAndTag(addedNode, function (_ref4) {
+            var rect = _ref4.rect;
+            var wasDeleted = removedNodeRects.some(function (nr) {
+              return sameRectDimensions(nr, rect);
+            });
+            if (wasDeleted) {
+              return 'mutation:element-replacement';
+            }
+            return 'mutation:element';
+          });
+        });
+      },
+      onAttributeMutation: function onAttributeMutation(_ref5) {
+        var _this$intersectionObs4;
+        var target = _ref5.target,
+          attributeName = _ref5.attributeName;
+        (_this$intersectionObs4 = _this.intersectionObserver) === null || _this$intersectionObs4 === void 0 || _this$intersectionObs4.watchAndTag(target, function (_ref6) {
+          var target = _ref6.target,
+            rect = _ref6.rect;
+          if (isContainedWithinMediaWrapper(target)) {
+            return {
+              type: 'mutation:media',
+              mutationData: {
+                attributeName: attributeName
+              }
+            };
+          }
+          var lastElementRect = _this.mapVisibleNodeRects.get(target);
+          if (lastElementRect && sameRectSize(rect, lastElementRect)) {
+            return {
+              type: 'mutation:attribute:no-layout-shift',
+              mutationData: {
+                attributeName: attributeName
+              }
+            };
+          }
+          return {
+            type: 'mutation:attribute',
+            mutationData: {
+              attributeName: attributeName
+            }
+          };
+        });
+      }
+    });
+    this.performanceObserver = createPerformanceObserver({
+      onLayoutShift: function onLayoutShift(_ref7) {
+        var time = _ref7.time,
+          changedRects = _ref7.changedRects;
+        var _iterator = _createForOfIteratorHelper(changedRects),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var changedRect = _step.value;
+            onChange({
+              time: time,
+              elementRef: new WeakRef(changedRect.node),
+              visible: true,
+              rect: changedRect.rect,
+              previousRect: changedRect.previousRect,
+              type: 'layout-shift'
+            });
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+    });
+  }
+  return _createClass(ViewportObserver, [{
+    key: "start",
+    value: function start() {
+      var _this$mutationObserve, _this$performanceObse;
+      (_this$mutationObserve = this.mutationObserver) === null || _this$mutationObserve === void 0 || _this$mutationObserve.observe(document.body, {
+        attributeOldValue: true,
+        attributes: true,
+        childList: true,
+        subtree: true
+      });
+      (_this$performanceObse = this.performanceObserver) === null || _this$performanceObse === void 0 || _this$performanceObse.observe({
+        type: 'layout-shift',
+        buffered: true,
+        // @ts-ignore-error
+        durationThreshold: 30
+      });
+    }
+  }, {
+    key: "stop",
+    value: function stop() {
+      var _this$mutationObserve2, _this$intersectionObs5, _this$performanceObse2;
+      (_this$mutationObserve2 = this.mutationObserver) === null || _this$mutationObserve2 === void 0 || _this$mutationObserve2.disconnect();
+      (_this$intersectionObs5 = this.intersectionObserver) === null || _this$intersectionObs5 === void 0 || _this$intersectionObs5.disconnect();
+      (_this$performanceObse2 = this.performanceObserver) === null || _this$performanceObse2 === void 0 || _this$performanceObse2.disconnect();
+    }
+  }]);
+}();
+export { ViewportObserver as default };

package/dist/esm/vc/vc-observer-new/viewport-observer/intersection-observer/index.js

@@ -0,0 +1,65 @@
+function isValidEntry(entry) {
+  return entry.isIntersecting && entry.intersectionRect.width > 0 && entry.intersectionRect.height > 0;
+}
+export function createIntersectionObserver(args) {
+  if (!window || typeof window.IntersectionObserver !== 'function') {
+    return null;
+  }
+  var callbacksPerElement = new WeakMap();
+  var observer = new IntersectionObserver(function (entries) {
+    var _args$onObserved;
+    var validEntries = [];
+    var startTime = performance.now();
+    entries.forEach(function (entry) {
+      var _mutationTag;
+      if (!(entry.target instanceof HTMLElement) || !isValidEntry(entry)) {
+        return;
+      }
+      var mutationTag = null;
+      var mutationData = null;
+      var tagOrCallback = callbacksPerElement.get(entry.target);
+      if (typeof tagOrCallback === 'function') {
+        var tagOrCallbackResult = tagOrCallback({
+          target: entry.target,
+          rect: entry.intersectionRect
+        });
+        if (!tagOrCallbackResult) {
+          mutationTag = 'unknown';
+        } else if (typeof tagOrCallbackResult === 'string') {
+          mutationTag = tagOrCallbackResult;
+        } else {
+          mutationTag = tagOrCallbackResult.type;
+          mutationData = tagOrCallbackResult.mutationData;
+        }
+      } else if (typeof tagOrCallback === 'string') {
+        mutationTag = tagOrCallback;
+      }
+      args.onEntry({
+        target: entry.target,
+        rect: entry.intersectionRect,
+        time: entry.time,
+        type: (_mutationTag = mutationTag) !== null && _mutationTag !== void 0 ? _mutationTag : 'unknown',
+        mutationData: mutationData
+      });
+      validEntries.push(new WeakRef(entry.target));
+      callbacksPerElement.delete(entry.target);
+      observer.unobserve(entry.target);
+    });
+    (_args$onObserved = args.onObserved) === null || _args$onObserved === void 0 || _args$onObserved.call(args, {
+      time: startTime,
+      elements: validEntries
+    });
+  });
+  return {
+    disconnect: function disconnect() {
+      observer.disconnect();
+    },
+    unobserve: function unobserve(target) {
+      observer.unobserve(target);
+    },
+    watchAndTag: function watchAndTag(target, tagOrCallback) {
+      callbacksPerElement.set(target, tagOrCallback);
+      observer.observe(target);
+    }
+  };
+}

package/dist/esm/vc/vc-observer-new/viewport-observer/mutation-observer/index.js

@@ -0,0 +1,59 @@
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+export default function createMutationObserver(_ref) {
+  var onAttributeMutation = _ref.onAttributeMutation,
+    onChildListMutation = _ref.onChildListMutation,
+    onMutationFinished = _ref.onMutationFinished;
+  if (!window || typeof window.IntersectionObserver !== 'function') {
+    return null;
+  }
+  var observer = new MutationObserver(function (mutations) {
+    var addedNodes = [];
+    var removedNodes = [];
+    var targets = [];
+    var _iterator = _createForOfIteratorHelper(mutations),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var mut = _step.value;
+        if (!(mut.target instanceof HTMLElement)) {
+          continue;
+        }
+        if (mut.type === 'attributes') {
+          var _mut$attributeName;
+          onAttributeMutation({
+            target: mut.target,
+            attributeName: (_mut$attributeName = mut.attributeName) !== null && _mut$attributeName !== void 0 ? _mut$attributeName : 'unknown'
+          });
+          continue;
+        } else if (mut.type === 'childList') {
+          var _mut$addedNodes, _mut$removedNodes;
+          ((_mut$addedNodes = mut.addedNodes) !== null && _mut$addedNodes !== void 0 ? _mut$addedNodes : []).forEach(function (node) {
+            if (node instanceof HTMLElement) {
+              addedNodes.push(node);
+            }
+          });
+          ((_mut$removedNodes = mut.removedNodes) !== null && _mut$removedNodes !== void 0 ? _mut$removedNodes : []).forEach(function (node) {
+            if (node instanceof HTMLElement) {
+              removedNodes.push(node);
+            }
+          });
+        }
+        targets.push(mut.target);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    onChildListMutation({
+      addedNodes: addedNodes,
+      removedNodes: removedNodes
+    });
+    onMutationFinished === null || onMutationFinished === void 0 || onMutationFinished({
+      targets: targets
+    });
+  });
+  return observer;
+}

package/dist/esm/vc/vc-observer-new/viewport-observer/performance-observer/index.js

@@ -0,0 +1,51 @@
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+// The LayoutShiftAttribution API is returning the numbers on physical dimension
+export function convertPhysicalToLogicalResolution(rect) {
+  if (typeof window.devicePixelRatio !== 'number') {
+    return rect;
+  }
+  if (window.devicePixelRatio === 1) {
+    return rect;
+  }
+
+  // eslint-disable-next-line compat/compat
+  return new DOMRect(rect.x / window.devicePixelRatio, rect.y / window.devicePixelRatio, rect.width / window.devicePixelRatio, rect.height / window.devicePixelRatio);
+}
+export default function createPerformanceObserver(args) {
+  if (!window || typeof window.PerformanceObserver !== 'function') {
+    return null;
+  }
+  var onLayoutShift = args.onLayoutShift;
+  var observer = new PerformanceObserver(function (entries) {
+    var _iterator = _createForOfIteratorHelper(entries.getEntries()),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var entry = _step.value;
+        if (entry.entryType === 'layout-shift') {
+          // Ignored via go/ees005
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          var changedRects = entry.sources.reduceRight(function (acc, attr) {
+            acc.push({
+              rect: convertPhysicalToLogicalResolution(attr.currentRect),
+              previousRect: convertPhysicalToLogicalResolution(attr.previousRect),
+              node: attr.node
+            });
+            return acc;
+          }, []);
+          onLayoutShift({
+            time: entry.startTime,
+            changedRects: changedRects
+          });
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  });
+  return observer;
+}

package/dist/esm/vc/vc-observer-new/window-event-observer/index.js

@@ -0,0 +1,48 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { bind } from 'bind-event-listener';
+var WindowEventObserver = /*#__PURE__*/function () {
+  function WindowEventObserver(opts) {
+    _classCallCheck(this, WindowEventObserver);
+    _defineProperty(this, "unbindFns", []);
+    this.onEvent = opts.onEvent;
+  }
+  return _createClass(WindowEventObserver, [{
+    key: "bindEvent",
+    value: function bindEvent(type) {
+      var _this = this;
+      var unbindCallback = bind(window, {
+        type: type,
+        listener: function listener(event) {
+          _this.onEvent({
+            time: event.timeStamp,
+            type: type,
+            event: event
+          });
+        },
+        options: {
+          passive: true
+        }
+      });
+      this.unbindFns.push(unbindCallback);
+    }
+  }, {
+    key: "start",
+    value: function start() {
+      this.bindEvent('wheel');
+      this.bindEvent('scroll');
+      this.bindEvent('keydown');
+      this.bindEvent('resize');
+    }
+  }, {
+    key: "stop",
+    value: function stop() {
+      this.unbindFns.forEach(function (cb) {
+        cb();
+      });
+      this.unbindFns = [];
+    }
+  }]);
+}();
+export { WindowEventObserver as default };

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

@@ -1,5 +1,6 @@
 export type { AssetResourceEntry, AssetsClassification, AssetsData, AssetsReporter, } from './assets/types';
 export type { LifecycleMarkType, MarkType, SpanType, InteractionType, AbortReasonType, CustomTiming, HoldInfo, LoadProfilerEventInfo, ReactProfilerTiming, Span, Mark, InteractionError, RequestInfo, ApdexType, SegmentInfo, CustomData, HoldActive, Redirect, InteractionMetrics, EnhancedUFOInteractionContextType, BM3Event, PostInteractionLogOutput, LastInteractionFinishInfo, } from './common/types';
+export type { MultiHeatmapPayload } from './vc/types';
 /**
  * @deprecated Prefer import from @atlaskit/react-ufo/interaction-context
  */

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

@@ -1,5 +1,6 @@
 import type { InteractionMetrics } from '../common';
-import { VCObserver, type VCObserverOptions } from '../vc/vc-observer';
+import type { VCObserverOptions } from '../vc/types';
+import { VCObserver } from '../vc/vc-observer';
 type InteractionMetricsHandler = (interactionId: string, interaction: InteractionMetrics) => void | Promise<void>;
 export declare function installInteractionSink(handler: InteractionMetricsHandler): void;
 export declare function sinkExperimentalHandler(sinkFn: (interactionId: string, interaction: InteractionMetrics) => void | Promise<void>): void;
@@ -12,5 +13,5 @@ export declare class ExperimentalVCMetrics {
     }): void;
 }
 export declare const experimentalVC: ExperimentalVCMetrics;
-export declare const getExperimentalVCMetrics: (interaction: InteractionMetrics) => import("../common/vc/types").VCResult | null;
+export declare const getExperimentalVCMetrics: (interaction: InteractionMetrics) => Promise<import("../common/vc/types").VCResult | null>;
 export {};

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

@@ -1,7 +1,7 @@
 import type { InteractionMetrics, InteractionType } from '../common';
 import * as ssr from '../ssr';
 import type { OptimizedLabelStack } from './common/types';
-export declare function createPayloads(interactionId: string, interaction: InteractionMetrics): {
+export declare function createPayloads(interactionId: string, interaction: InteractionMetrics): Promise<{
     actionSubject: string;
     action: string;
     eventType: string;
@@ -11594,8 +11594,8 @@ export declare function createPayloads(interactionId: string, interaction: Inter
             'experience:name': string;
         };
     };
-}[];
-export declare function createExperimentalMetricsPayload(interactionId: string, interaction: InteractionMetrics): {
+}[]>;
+export declare function createExperimentalMetricsPayload(interactionId: string, interaction: InteractionMetrics): Promise<{
     actionSubject: string;
     action: string;
     eventType: string;
@@ -23188,4 +23188,4 @@ export declare function createExperimentalMetricsPayload(interactionId: string,
             'experience:name': string;
         };
     };
-} | null;
+}> | null;

package/dist/types/interaction-metrics/post-interaction-log.d.ts

@@ -1,7 +1,8 @@
 import { type LastInteractionFinishInfo, type PostInteractionLogOutput, type ReactProfilerTiming } from '../common/common/types';
 import type { VCResult } from '../common/vc/types';
 import type { LabelStack } from '../interaction-context';
-import { VCObserver, type VCObserverOptions } from '../vc/vc-observer';
+import type { VCObserverOptions } from '../vc/types';
+import { VCObserver } from '../vc/vc-observer';
 export default class PostInteractionLog {
     /**
      * Basic info about interaction that has just finished
@@ -55,7 +56,7 @@ export default class PostInteractionLog {
     /**
      * Send the log if there is data
      */
-    sendPostInteractionLog(): void;
+    sendPostInteractionLog(): Promise<void>;
     /**
      * This fn should be invoked when an interaction has finished
      * Basic details about the finished interaction will be recorded

package/dist/types/segment/schedule-on-paint.d.ts

@@ -0,0 +1,2 @@
+export type OnPaintCallback = () => any;
+export default function scheduleOnPaint(callback: OnPaintCallback): void;

package/dist/types/vc/index.d.ts

@@ -1,5 +1,5 @@
-import { VCObserver, type VCObserverOptions } from './vc-observer';
+import type { VCObserverInterface, VCObserverOptions } from './types';
 declare global {
-    var __vcObserver: VCObserver;
+    var __vcObserver: VCObserverInterface;
 }
-export declare const getVCObserver: (opts?: VCObserverOptions) => VCObserver;
+export declare const getVCObserver: (opts?: VCObserverOptions) => VCObserverInterface;

package/dist/types/vc/types.d.ts

@@ -0,0 +1,34 @@
+import type { VCRawDataType, VCResult } from '../common/vc/types';
+export type GetVCResultType = {
+    start: number;
+    stop: number;
+    tti: number;
+    prefix?: string;
+    ssr?: number;
+    vc?: VCRawDataType | null;
+};
+export type SelectorConfig = {
+    id: boolean;
+    testId: boolean;
+    role: boolean;
+    className: boolean;
+    dataVC?: boolean;
+};
+export type VCObserverOptions = {
+    heatmapSize?: number | undefined;
+    oldDomUpdates?: boolean | undefined;
+    devToolsEnabled?: boolean | undefined;
+    selectorConfig?: SelectorConfig | undefined;
+    isPostInteraction?: boolean;
+};
+export interface VCObserverInterface {
+    start(startArg: {
+        startTime: number;
+    }): void;
+    stop(): void;
+    getVCRawData(): VCRawDataType | null;
+    getVCResult(param: GetVCResultType): Promise<VCResult>;
+    setSSRElement(element: HTMLElement): void;
+    setReactRootRenderStart(startTime?: number): void;
+    setReactRootRenderStop(stopTime?: number): void;
+}

package/dist/types/vc/vc-observer/index.d.ts

@@ -1,23 +1,9 @@
 import { type UnbindFn } from 'bind-event-listener';
-import type { ComponentsLogType, VCAbortReason, VCAbortReasonType, VCEntryType, VCIgnoreReason, VCRatioType, VCRawDataType, VCResult } from '../../common/vc/types';
+import type { ComponentsLogType, VCAbortReasonType, VCEntryType, VCIgnoreReason, VCRatioType, VCRawDataType, VCResult } from '../../common/vc/types';
+import type { GetVCResultType, VCObserverInterface, VCObserverOptions } from '../types';
 import { MultiRevisionHeatmap } from './heatmap/heatmap';
-import { Observers, type SelectorConfig } from './observers';
-type GetVCResultType = {
-    start: number;
-    stop: number;
-    tti: number;
-    prefix?: string;
-    ssr?: number;
-    vc?: VCRawDataType | null;
-};
-export type VCObserverOptions = {
-    heatmapSize?: number | undefined;
-    oldDomUpdates?: boolean | undefined;
-    devToolsEnabled?: boolean | undefined;
-    selectorConfig?: SelectorConfig | undefined;
-    isPostInteraction?: boolean;
-};
-export declare class VCObserver {
+import { Observers } from './observers';
+export declare class VCObserver implements VCObserverInterface {
     abortReason: VCAbortReasonType;
     outOfBoundaryInfo: string;
     /** config * */
@@ -55,7 +41,7 @@ export declare class VCObserver {
         targetName: string;
         ignoreReason: VCIgnoreReason | undefined;
     }[];
-    getVCResult: ({ start, stop, tti, prefix, ssr, vc }: GetVCResultType) => VCResult;
+    getVCResult: ({ start, stop, tti, prefix, ssr, vc, }: GetVCResultType) => Promise<VCResult>;
     static calculateVC({ heatmap, ssr, componentsLog, viewport, }: {
         heatmap: number[][];
         ssr?: number;
@@ -84,7 +70,6 @@ export declare class VCObserver {
     private handleUpdate;
     private legacyHandleUpdate;
     private onViewportChangeDetected;
-    abortObservation(abortReason?: VCAbortReason): void;
     private setAbortReason;
     private resetState;
     private getCleanHeatmap;
@@ -101,4 +86,3 @@ export declare class VCObserver {
     private measureStart;
     private measureStop;
 }
-export {};