@atlaskit/react-ufo 3.1.4 → 3.3.0

package/dist/cjs/vc/vc-observer-new/metric-calculator/percentile-calc/rect-sweeping-line/index.js

@@ -0,0 +1,107 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = calculateTTVCPercentiles;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _isViewportEntryData = _interopRequireDefault(require("../../utils/is-viewport-entry-data"));
+var _taskYield = _interopRequireDefault(require("../../utils/task-yield"));
+var _calcUnionArea = _interopRequireDefault(require("./calc-union-area"));
+function calculateTTVCPercentiles(_x) {
+  return _calculateTTVCPercentiles.apply(this, arguments);
+}
+function _calculateTTVCPercentiles() {
+  _calculateTTVCPercentiles = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(_ref) {
+    var orderedEntries, viewport, percentiles, sortedPercentiles, viewportArea, checkpoints, activeRects, removeActiveRect, domElementsBuffer, i, iEntry, iEntryData, rect, elementName, exclusionArea, currentArea, currVCPercent, matchesAnyCheckpoints, _checkpoint, domElements;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          orderedEntries = _ref.orderedEntries, viewport = _ref.viewport, percentiles = _ref.percentiles;
+          sortedPercentiles = (0, _toConsumableArray2.default)(percentiles).sort(function (a, b) {
+            return a - b;
+          });
+          viewportArea = viewport.width * viewport.height;
+          checkpoints = {};
+          activeRects = orderedEntries.filter(function (e) {
+            return (0, _isViewportEntryData.default)(e.data);
+          }).map(function (e) {
+            return e.data.rect;
+          });
+          removeActiveRect = function removeActiveRect(rectToRemove) {
+            var index = activeRects.indexOf(rectToRemove);
+            // Check if the element exists in the array
+            if (index !== -1) {
+              // Remove the element at the found index
+              activeRects.splice(index, 1);
+            }
+          };
+          domElementsBuffer = new Set();
+          i = 0;
+        case 8:
+          if (!(i < orderedEntries.length)) {
+            _context.next = 36;
+            break;
+          }
+          iEntry = orderedEntries[i];
+          iEntryData = iEntry.data;
+          if ((0, _isViewportEntryData.default)(iEntryData)) {
+            _context.next = 13;
+            break;
+          }
+          return _context.abrupt("continue", 33);
+        case 13:
+          rect = iEntryData.rect, elementName = iEntryData.elementName;
+          domElementsBuffer.add(elementName);
+          removeActiveRect(rect);
+          exclusionArea = (0, _calcUnionArea.default)(activeRects);
+          currentArea = viewportArea - exclusionArea;
+          currVCPercent = Math.round(currentArea / viewportArea * 100);
+          matchesAnyCheckpoints = false;
+        case 20:
+          if (!(sortedPercentiles.length > 0 && currVCPercent >= sortedPercentiles[0])) {
+            _context.next = 29;
+            break;
+          }
+          _checkpoint = sortedPercentiles.shift();
+          domElements = (0, _toConsumableArray2.default)(domElementsBuffer);
+          if (_checkpoint) {
+            _context.next = 25;
+            break;
+          }
+          return _context.abrupt("break", 29);
+        case 25:
+          matchesAnyCheckpoints = true;
+          checkpoints[_checkpoint.toString()] = {
+            t: iEntry.time,
+            e: domElements
+          };
+          _context.next = 20;
+          break;
+        case 29:
+          if (matchesAnyCheckpoints) {
+            domElementsBuffer.clear();
+          }
+          if (!(i % 500 === 0)) {
+            _context.next = 33;
+            break;
+          }
+          _context.next = 33;
+          return (0, _taskYield.default)();
+        case 33:
+          i++;
+          _context.next = 8;
+          break;
+        case 36:
+          return _context.abrupt("return", checkpoints);
+        case 37:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _calculateTTVCPercentiles.apply(this, arguments);
+}

package/dist/cjs/vc/vc-observer-new/metric-calculator/percentile-calc/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/cjs/vc/vc-observer-new/metric-calculator/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getViewportHeight;
+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/cjs/vc/vc-observer-new/metric-calculator/utils/get-viewport-width.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getViewportWidth;
+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/cjs/vc/vc-observer-new/metric-calculator/utils/is-viewport-entry-data.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isViewportEntryData;
+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/cjs/vc/vc-observer-new/metric-calculator/utils/task-yield.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = taskYield;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+// See https://developer.mozilla.org/en-US/docs/Web/API/Prioritized_Task_Scheduling_API
+function taskYield() {
+  return _taskYield.apply(this, arguments);
+}
+function _taskYield() {
+  _taskYield = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+    var resolve, p;
+    return _regenerator.default.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/cjs/vc/vc-observer-new/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

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

@@ -0,0 +1,195 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _vcUtils = require("../../vc-observer/media-wrapper/vc-utils");
+var _intersectionObserver = require("./intersection-observer");
+var _mutationObserver = _interopRequireDefault(require("./mutation-observer"));
+var _performanceObserver = _interopRequireDefault(require("./performance-observer"));
+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; }
+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 = exports.default = /*#__PURE__*/function () {
+  function ViewportObserver(_ref) {
+    var _this = this;
+    var onChange = _ref.onChange;
+    (0, _classCallCheck2.default)(this, ViewportObserver);
+    this.mapVisibleNodeRects = new WeakMap();
+    this.intersectionObserver = (0, _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 = (0, _mutationObserver.default)({
+      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 ((0, _vcUtils.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 ((0, _vcUtils.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 = (0, _performanceObserver.default)({
+      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 (0, _createClass2.default)(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();
+    }
+  }]);
+}();

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

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIntersectionObserver = createIntersectionObserver;
+function isValidEntry(entry) {
+  return entry.isIntersecting && entry.intersectionRect.width > 0 && entry.intersectionRect.height > 0;
+}
+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/cjs/vc/vc-observer-new/viewport-observer/mutation-observer/index.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createMutationObserver;
+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; }
+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/cjs/vc/vc-observer-new/viewport-observer/performance-observer/index.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertPhysicalToLogicalResolution = convertPhysicalToLogicalResolution;
+exports.default = createPerformanceObserver;
+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
+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);
+}
+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/cjs/vc/vc-observer-new/viewport-observer/types.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _bindEventListener = require("bind-event-listener");
+var WindowEventObserver = exports.default = /*#__PURE__*/function () {
+  function WindowEventObserver(opts) {
+    (0, _classCallCheck2.default)(this, WindowEventObserver);
+    (0, _defineProperty2.default)(this, "unbindFns", []);
+    this.onEvent = opts.onEvent;
+  }
+  return (0, _createClass2.default)(WindowEventObserver, [{
+    key: "bindEvent",
+    value: function bindEvent(type) {
+      var _this = this;
+      var unbindCallback = (0, _bindEventListener.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 = [];
+    }
+  }]);
+}();