@atlaskit/react-ufo 2.14.2 → 2.15.0

package/dist/esm/vc/vc-observer/heatmap/heatmap.js

@@ -0,0 +1,268 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _objectDestructuringEmpty from "@babel/runtime/helpers/objectDestructuringEmpty";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+var UNUSED_SECTOR = 0;
+export var MultiRevisionHeatmap = /*#__PURE__*/function () {
+  function MultiRevisionHeatmap(_ref) {
+    var _this = this;
+    var viewport = _ref.viewport,
+      revisions = _ref.revisions,
+      arraySize = _ref.arraySize,
+      devToolsEnabled = _ref.devToolsEnabled;
+    _classCallCheck(this, MultiRevisionHeatmap);
+    _defineProperty(this, "arraySize", {
+      w: 200,
+      h: 200
+    });
+    _defineProperty(this, "mapPixelsToHeatmap", function (left, top, width, height) {
+      var _this$viewport = _this.viewport,
+        w = _this$viewport.w,
+        h = _this$viewport.h;
+      var l = Math.floor(left / w * _this.arraySize.w);
+      var t = Math.floor(top / h * _this.arraySize.h);
+      var r = Math.ceil((left + width) / w * _this.arraySize.w);
+      var b = Math.ceil((top + height) / h * _this.arraySize.h);
+
+      // correct values to min - 0, max - arraySize
+      var result = {
+        l: Math.max(0, l),
+        t: Math.max(0, t),
+        r: Math.min(_this.arraySize.w, r),
+        b: Math.min(_this.arraySize.h, b)
+      };
+      return result;
+    });
+    _defineProperty(this, "getElementRatio", function (mappedValues) {
+      var r = mappedValues.r,
+        l = mappedValues.l,
+        b = mappedValues.b,
+        t = mappedValues.t;
+      return (r - l) * (b - t) / (_this.arraySize.w * _this.arraySize.h);
+    });
+    this.viewport = viewport;
+    this.revisions = revisions;
+    if (arraySize) {
+      this.arraySize = arraySize;
+    }
+    this.heatmaps = new Array(revisions.length);
+    this.componentsLogs = new Array(revisions.length);
+    this.vcRatios = new Array(revisions.length);
+    this.devToolsEnabled = devToolsEnabled || false;
+    revisions.forEach(function (_ref2, i) {
+      _objectDestructuringEmpty(_ref2);
+      _this.heatmaps[i] = _this.getCleanHeatmap();
+      _this.componentsLogs[i] = {};
+      _this.vcRatios[i] = {};
+    });
+  }
+  return _createClass(MultiRevisionHeatmap, [{
+    key: "handleUpdate",
+    value: function handleUpdate(_ref3) {
+      var _this2 = this;
+      var time = _ref3.time,
+        type = _ref3.type,
+        classification = _ref3.classification,
+        intersectionRect = _ref3.intersectionRect,
+        element = _ref3.element,
+        targetName = _ref3.targetName,
+        ignoreReason = _ref3.ignoreReason,
+        onError = _ref3.onError;
+      var mappedValues = this.mapPixelsToHeatmap(intersectionRect.left, intersectionRect.top, intersectionRect.width, intersectionRect.height);
+      var result = this.applyChangesToHeatMap(mappedValues, time, classification);
+      if (result !== true) {
+        onError(result);
+      }
+      var componentRatio = this.getElementRatio(mappedValues);
+      this.revisions.forEach(function (_, i) {
+        if (classification[i]) {
+          _this2.vcRatios[i][targetName] = componentRatio;
+        }
+        if (!_this2.componentsLogs[i][time]) {
+          _this2.componentsLogs[i][time] = [];
+        }
+        _this2.componentsLogs[i][time].push({
+          __debug__element: _this2.devToolsEnabled ? new WeakRef(element) : null,
+          intersectionRect: intersectionRect,
+          targetName: targetName,
+          ignoreReason: ignoreReason
+        });
+      });
+    }
+  }, {
+    key: "getData",
+    value: function getData() {
+      return {
+        heatmaps: this.heatmaps
+      };
+    }
+  }, {
+    key: "getPayloadShapedData",
+    value: function getPayloadShapedData(args) {
+      var result = this.processData(args);
+      var payload = this.revisions.map(function (rev, i) {
+        var vcDetails = {};
+        args.VCParts.forEach(function (VCPart) {
+          vcDetails[VCPart] = {
+            t: result[i].VC[VCPart] || 0,
+            e: Array.from(result[i].VCBox[VCPart] || [])
+          };
+        });
+        return {
+          revision: rev.name,
+          vcDetails: vcDetails,
+          clean: args.clean,
+          'metric:vc90': null // will be set or not in the payload generator
+        };
+      });
+      return payload;
+    }
+  }, {
+    key: "processData",
+    value: function processData(_ref4) {
+      var _this3 = this;
+      var VCParts = _ref4.VCParts,
+        _ref4$ssr = _ref4.ssr,
+        ssr = _ref4$ssr === void 0 ? UNUSED_SECTOR : _ref4$ssr;
+      return this.heatmaps.map(function (heatmap, i) {
+        var lastUpdate = {};
+        var totalPainted = 0;
+        var componentsLog = _this3.componentsLogs[i];
+        if (ssr !== UNUSED_SECTOR) {
+          var _window$document;
+          var element = {
+            __debug__element: new WeakRef((_window$document = window.document) === null || _window$document === void 0 ? void 0 : _window$document.body),
+            intersectionRect: {
+              top: 0,
+              left: 0,
+              right: 0,
+              bottom: 0,
+              x: 0,
+              y: 0,
+              width: _this3.viewport.w,
+              height: _this3.viewport.h,
+              toJSON: function toJSON() {
+                return {};
+              }
+            },
+            targetName: 'SSR'
+          };
+          if (!componentsLog[ssr]) {
+            componentsLog[ssr] = [];
+          }
+          componentsLog[ssr].push(element);
+        }
+        for (var _i = 0; _i < heatmap.length; _i++) {
+          var rounded = Math.floor(heatmap[_i] === UNUSED_SECTOR && ssr !== UNUSED_SECTOR ? ssr : heatmap[_i]);
+          totalPainted += rounded !== UNUSED_SECTOR ? 1 : 0;
+          if (rounded !== UNUSED_SECTOR) {
+            lastUpdate[rounded] = lastUpdate[rounded] ? lastUpdate[rounded] + 1 : 1;
+          }
+        }
+        var entries = Object.entries(lastUpdate).map(function (a) {
+          return [parseInt(a[0], 10), a[1]];
+        }).sort(function (a, b) {
+          return a[0] > b[0] ? 1 : -1;
+        });
+        var VC = MultiRevisionHeatmap.makeVCReturnObj(VCParts);
+        var VCBox = MultiRevisionHeatmap.makeVCReturnObj(VCParts);
+        entries.reduce(function () {
+          var acc = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+          var v = arguments.length > 1 ? arguments[1] : undefined;
+          var VCRatio = v[1] / totalPainted + acc;
+          var time = v[0];
+          VCParts.forEach(function (value) {
+            if ((VC[value] === null || VC[value] === undefined) && VCRatio >= value / 100) {
+              var _componentsLog$time;
+              VC[value] = time;
+              VCBox[value] = new Set();
+              (_componentsLog$time = componentsLog[time]) === null || _componentsLog$time === void 0 || _componentsLog$time.forEach(function (v) {
+                var _VCBox$value;
+                return (_VCBox$value = VCBox[value]) === null || _VCBox$value === void 0 ? void 0 : _VCBox$value.add(v.targetName);
+              });
+            }
+          });
+          return VCRatio;
+        }, 0);
+        var VCEntries = entries.reduce(function (acc, _ref5, i) {
+          var _acc$abs, _componentsLog$timest;
+          var _ref6 = _slicedToArray(_ref5, 2),
+            timestamp = _ref6[0],
+            entryPainted = _ref6[1];
+          var currentlyPainted = entryPainted + (((_acc$abs = acc.abs[i - 1]) === null || _acc$abs === void 0 ? void 0 : _acc$abs[1]) || 0);
+          var currentlyPaintedRatio = Math.round(currentlyPainted / totalPainted * 1000) / 10;
+          var logEntry = (_componentsLog$timest = componentsLog[timestamp]) === null || _componentsLog$timest === void 0 ? void 0 : _componentsLog$timest.map(function (v) {
+            return v.targetName;
+          });
+          acc.abs.push([timestamp, currentlyPainted]);
+          acc.rel.push({
+            time: timestamp,
+            vc: currentlyPaintedRatio,
+            elements: logEntry
+          });
+          return acc;
+        }, {
+          abs: [],
+          rel: []
+        });
+        return {
+          VC: VC,
+          VCBox: VCBox,
+          VCEntries: VCEntries,
+          totalPainted: totalPainted
+        };
+      });
+    }
+  }, {
+    key: "applyChangesToHeatMap",
+    value: function applyChangesToHeatMap(a, time, classification) {
+      var l = a.l,
+        t = a.t,
+        r = a.r,
+        b = a.b;
+      var size = classification.length;
+      for (var row = t; row < b; row++) {
+        if (this.heatmaps[0][row] === undefined) {
+          try {
+            return {
+              error: "index - ".concat(row),
+              time: time
+            };
+          } catch (e) {
+            return {
+              error: 'row error',
+              time: time
+            };
+          }
+        } else {
+          for (var heatmapIndex = 0; heatmapIndex < size; heatmapIndex++) {
+            if (classification[heatmapIndex]) {
+              this.heatmaps[heatmapIndex].fill(time, this.getIndex(l, row), this.getIndex(r, row));
+            }
+          }
+        }
+      }
+      return true;
+    }
+  }, {
+    key: "getIndex",
+    value: function getIndex(x, y) {
+      return x + this.arraySize.w * y;
+    }
+  }, {
+    key: "getCleanHeatmap",
+    value: function getCleanHeatmap() {
+      return new Uint32Array(this.arraySize.w * this.arraySize.h);
+    }
+  }], [{
+    key: "makeVCReturnObj",
+    value: function makeVCReturnObj(VCParts) {
+      var vc = {};
+      VCParts.forEach(function (v) {
+        vc[v] = null;
+      });
+      return vc;
+    }
+  }]);
+}();

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

@@ -9,7 +9,9 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 import { fg } from '@atlaskit/platform-feature-flags';
 import { attachAbortListeners } from './attachAbortListeners';
 import { getViewportHeight, getViewportWidth } from './getViewport';
+import { MultiRevisionHeatmap } from './heatmap/heatmap';
 import { Observers } from './observers';
+import { getRevisions } from './revisions/revisions';
 var abortReason = {
   scroll: 'scroll',
   keypress: 'keypress',
@@ -47,6 +49,7 @@ export var VCObserver = /*#__PURE__*/function () {
     });
     /* heatmap */
     _defineProperty(this, "arraySize", 0);
+    _defineProperty(this, "multiHeatmap", null);
     _defineProperty(this, "componentsLog", {});
     _defineProperty(this, "vcRatios", {});
     _defineProperty(this, "active", false);
@@ -78,6 +81,7 @@ export var VCObserver = /*#__PURE__*/function () {
         abortReason: _objectSpread({}, _this.abortReason),
         heatmap: _this.heatmap,
         heatmapNext: _this.heatmapNext,
+        multiHeatmap: _this.multiHeatmap,
         outOfBoundaryInfo: _this.outOfBoundaryInfo,
         totalTime: Math.round(_this.totalTime + _this.observers.getTotalTime()),
         componentsLog: _objectSpread({}, _this.componentsLog),
@@ -110,7 +114,8 @@ export var VCObserver = /*#__PURE__*/function () {
         componentsLog = rawData.componentsLog,
         viewport = rawData.viewport,
         devToolsEnabled = rawData.devToolsEnabled,
-        ratios = rawData.ratios;
+        ratios = rawData.ratios,
+        multiHeatmap = rawData.multiHeatmap;
       if (abortReasonInfo !== null && abortReason.blocking) {
         // exposing data to devtools
         try {
@@ -146,6 +151,7 @@ export var VCObserver = /*#__PURE__*/function () {
         /* empty */
       }
       var _componentsLog = {};
+      // eslint-disable-next-line @atlaskit/platform/ensure-feature-flag-prefix
       if (fg('ufo-remove-vc-component-observations-after-ttai')) {
         Object.entries(_this.componentsLog).forEach(function (_ref5) {
           var _ref6 = _slicedToArray(_ref5, 2),
@@ -202,9 +208,30 @@ export var VCObserver = /*#__PURE__*/function () {
               tti: tti,
               ttai: stop - start
             },
+            start: start,
+            stop: stop,
             heatmap: heatmap,
             ratios: ratios
           };
+          window.__vcNext = {
+            entries: vcNext.VCEntries.rel,
+            log: componentsLog,
+            metrics: {
+              '75': vcNext.VC['75'],
+              '80': vcNext.VC['80'],
+              '85': vcNext.VC['85'],
+              '90': vcNext.VC['90'],
+              '95': vcNext.VC['95'],
+              '98': vcNext.VC['98'],
+              '99': vcNext.VC['99'],
+              tti: tti,
+              ttai: stop - start
+            },
+            start: start,
+            stop: stop,
+            heatmap: heatmapNext,
+            ratios: ratios
+          };
 
           // Emitting a custom event to make it available in the Chrome extension
           window.dispatchEvent(new CustomEvent('vcReady', {
@@ -217,12 +244,36 @@ export var VCObserver = /*#__PURE__*/function () {
       } catch (e) {
         /*  do nothing */
       }
-      return _objectSpread(_objectSpread(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
+      var isMultiHeatmapEnabled = fg('ufo_vc_multiheatmap');
+      var revisionsData = isMultiHeatmapEnabled && multiHeatmap !== null ? _defineProperty({}, "".concat(fullPrefix, "vc:rev"), multiHeatmap.getPayloadShapedData({
+        VCParts: VCObserver.VCParts.map(function (v) {
+          return parseInt(v);
+        }),
+        ssr: ssr,
+        clean: !abortReasonInfo
+      })) : null;
+      // eslint-disable-next-line @atlaskit/platform/ensure-feature-flag-prefix
+      var isCalcSpeedIndexEnabled = fg('ufo-calc-speed-index');
+      return _objectSpread(_objectSpread(_objectSpread(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
         'metrics:vc': VC
-      }, "".concat(fullPrefix, "vc:state"), true), "".concat(fullPrefix, "vc:clean"), !abortReasonInfo), "".concat(fullPrefix, "vc:dom"), VCBox), "".concat(fullPrefix, "vc:updates"), VCEntries.rel.slice(0, 50)), "".concat(fullPrefix, "vc:size"), viewport), "".concat(fullPrefix, "vc:time"), Math.round(totalTime + (stopTime - startTime))), "".concat(fullPrefix, "vc:total"), totalPainted), "".concat(fullPrefix, "vc:ratios"), ratios), outOfBoundary), {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, "".concat(fullPrefix, "vc:next"), vcNext.VC), "".concat(fullPrefix, "vc:next:updates"), vcNext.VCEntries.rel.slice(0, 50)), "".concat(fullPrefix, "vc:next:dom"), vcNext.VCBox), "".concat(fullPrefix, "vc:ignored"), _this.getIgnoredElements(componentsLog)));
+      }, "".concat(fullPrefix, "vc:state"), true), "".concat(fullPrefix, "vc:clean"), !abortReasonInfo), "".concat(fullPrefix, "vc:dom"), VCBox), "".concat(fullPrefix, "vc:updates"), VCEntries.rel.slice(0, 50)), "".concat(fullPrefix, "vc:size"), viewport), "".concat(fullPrefix, "vc:time"), Math.round(totalTime + (stopTime - startTime))), "".concat(fullPrefix, "vc:total"), totalPainted), "".concat(fullPrefix, "vc:ratios"), ratios), outOfBoundary), {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, "".concat(fullPrefix, "vc:next"), vcNext.VC), "".concat(fullPrefix, "vc:next:updates"), vcNext.VCEntries.rel.slice(0, 50)), "".concat(fullPrefix, "vc:next:dom"), vcNext.VCBox), "".concat(fullPrefix, "vc:ignored"), _this.getIgnoredElements(componentsLog)), revisionsData), {}, _defineProperty(_defineProperty({}, "ufo:speedIndex", isCalcSpeedIndexEnabled ? VCEntries.speedIndex : undefined), "ufo:next:speedIndex", isCalcSpeedIndexEnabled ? vcNext.VCEntries.speedIndex : undefined));
     });
     _defineProperty(this, "handleUpdate", function (rawTime, intersectionRect, targetName, element, type, ignoreReason) {
       _this.measureStart();
+      _this.legacyHandleUpdate(rawTime, intersectionRect, targetName, element, type, ignoreReason);
+      if (fg('ufo_vc_multiheatmap')) {
+        _this.onViewportChangeDetected({
+          timestamp: rawTime,
+          intersectionRect: intersectionRect,
+          targetName: targetName,
+          element: element,
+          type: type,
+          ignoreReason: ignoreReason
+        });
+      }
+      _this.measureStop();
+    });
+    _defineProperty(this, "legacyHandleUpdate", function (rawTime, intersectionRect, targetName, element, type, ignoreReason) {
       if (_this.abortReason.reason === null || _this.abortReason.blocking === false) {
         var time = Math.round(rawTime - _this.startTime);
         var mappedValues = _this.mapPixelsToHeatmap(intersectionRect.left, intersectionRect.top, intersectionRect.width, intersectionRect.height);
@@ -243,8 +294,38 @@ export var VCObserver = /*#__PURE__*/function () {
           ignoreReason: ignoreReason
         });
       }
-      // devtools export
-      _this.measureStop();
+    });
+    _defineProperty(this, "onViewportChangeDetected", function (_ref9) {
+      var element = _ref9.element,
+        type = _ref9.type,
+        ignoreReason = _ref9.ignoreReason,
+        timestamp = _ref9.timestamp,
+        targetName = _ref9.targetName,
+        intersectionRect = _ref9.intersectionRect;
+      if (_this.multiHeatmap === null) {
+        return;
+      }
+      // @todo add abort reason handling
+      var time = Math.round(timestamp - _this.startTime);
+      var revisions = getRevisions();
+      var revisionsClassification = revisions.map(function (revision) {
+        return revision.classifier.classifyUpdate({
+          element: element,
+          type: type,
+          ignoreReason: ignoreReason
+        });
+      }, []);
+      _this.multiHeatmap.handleUpdate({
+        time: time,
+        targetName: targetName,
+        intersectionRect: intersectionRect,
+        type: type,
+        element: element,
+        classification: revisionsClassification,
+        onError: function onError(error) {
+          _this.setAbortReason(abortReason.error, error.time, error.error);
+        }
+      });
     });
     _defineProperty(this, "mapPixelsToHeatmap", function (left, top, width, height) {
       var _this$viewport = _this.viewport,
@@ -302,10 +383,10 @@ export var VCObserver = /*#__PURE__*/function () {
       var unbinds = attachAbortListeners(window, _this.viewport, _this.abortReasonCallback);
       if ((_window = window) !== null && _window !== void 0 && _window.__SSR_ABORT_LISTENERS__) {
         var _window2;
-        Object.entries(window.__SSR_ABORT_LISTENERS__.aborts).forEach(function (_ref8) {
-          var _ref9 = _slicedToArray(_ref8, 2),
-            key = _ref9[0],
-            time = _ref9[1];
+        Object.entries(window.__SSR_ABORT_LISTENERS__.aborts).forEach(function (_ref10) {
+          var _ref11 = _slicedToArray(_ref10, 2),
+            key = _ref11[0],
+            time = _ref11[1];
           if (time) {
             _this.abortReasonCallback(key, time);
           }
@@ -329,12 +410,19 @@ export var VCObserver = /*#__PURE__*/function () {
     });
     this.heatmap = this.getCleanHeatmap();
     this.heatmapNext = this.getCleanHeatmap();
+    if (fg('ufo_vc_multiheatmap')) {
+      this.multiHeatmap = new MultiRevisionHeatmap({
+        viewport: this.viewport,
+        revisions: getRevisions(),
+        devToolsEnabled: this.devToolsEnabled
+      });
+    }
     this.isPostInteraction = options.isPostInteraction || false;
   }
   return _createClass(VCObserver, [{
     key: "start",
-    value: function start(_ref10) {
-      var startTime = _ref10.startTime;
+    value: function start(_ref12) {
+      var startTime = _ref12.startTime;
       this.active = true;
       if (this.observers.isBrowserSupported()) {
         this.setViewportSize();
@@ -356,12 +444,12 @@ export var VCObserver = /*#__PURE__*/function () {
   }, {
     key: "getIgnoredElements",
     value: function getIgnoredElements(componentsLog) {
-      return Object.values(componentsLog).flat().filter(function (_ref11) {
-        var ignoreReason = _ref11.ignoreReason;
+      return Object.values(componentsLog).flat().filter(function (_ref13) {
+        var ignoreReason = _ref13.ignoreReason;
         return Boolean(ignoreReason);
-      }).map(function (_ref12) {
-        var targetName = _ref12.targetName,
-          ignoreReason = _ref12.ignoreReason;
+      }).map(function (_ref14) {
+        var targetName = _ref14.targetName,
+          ignoreReason = _ref14.ignoreReason;
         return {
           targetName: targetName,
           ignoreReason: ignoreReason
@@ -482,12 +570,12 @@ export var VCObserver = /*#__PURE__*/function () {
     }
   }], [{
     key: "calculateVC",
-    value: function calculateVC(_ref13) {
-      var heatmap = _ref13.heatmap,
-        _ref13$ssr = _ref13.ssr,
-        ssr = _ref13$ssr === void 0 ? UNUSED_SECTOR : _ref13$ssr,
-        componentsLog = _ref13.componentsLog,
-        viewport = _ref13.viewport;
+    value: function calculateVC(_ref15) {
+      var heatmap = _ref15.heatmap,
+        _ref15$ssr = _ref15.ssr,
+        ssr = _ref15$ssr === void 0 ? UNUSED_SECTOR : _ref15$ssr,
+        componentsLog = _ref15.componentsLog,
+        viewport = _ref15.viewport;
       var lastUpdate = {};
       var totalPainted = 0;
       if (ssr !== UNUSED_SECTOR) {
@@ -530,10 +618,19 @@ export var VCObserver = /*#__PURE__*/function () {
       });
       var VC = VCObserver.makeVCReturnObj();
       var VCBox = VCObserver.makeVCReturnObj();
+
+      // eslint-disable-next-line @atlaskit/platform/ensure-feature-flag-prefix
+      var isCalcSpeedIndexEnabled = fg('ufo-calc-speed-index');
       entries.reduce(function () {
         var acc = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
         var v = arguments.length > 1 ? arguments[1] : undefined;
-        var VCRatio = v[1] / totalPainted + acc;
+        var currRatio = v[1] / totalPainted;
+        var VCRatio = currRatio + acc;
+        if (fg('platform_ufo_fix_vc_observer_rounding_error')) {
+          var preciseCurrRatio = Math.round(100 * (v[1] / totalPainted));
+          var preciseAccRatio = Math.round(acc * 100);
+          VCRatio = (preciseCurrRatio + preciseAccRatio) / 100;
+        }
         var time = v[0];
         VCObserver.VCParts.forEach(function (key) {
           var value = parseInt(key, 10);
@@ -547,16 +644,21 @@ export var VCObserver = /*#__PURE__*/function () {
         });
         return VCRatio;
       }, 0);
-      var VCEntries = entries.reduce(function (acc, _ref14, i) {
-        var _acc$abs, _componentsLog$timest;
-        var _ref15 = _slicedToArray(_ref14, 2),
-          timestamp = _ref15[0],
-          entryPainted = _ref15[1];
+      var VCEntries = entries.reduce(function (acc, _ref16, i) {
+        var _acc$abs, _componentsLog$timest, _acc$rel$vc, _acc$rel;
+        var _ref17 = _slicedToArray(_ref16, 2),
+          timestamp = _ref17[0],
+          entryPainted = _ref17[1];
         var currentlyPainted = entryPainted + (((_acc$abs = acc.abs[i - 1]) === null || _acc$abs === void 0 ? void 0 : _acc$abs[1]) || 0);
         var currentlyPaintedRatio = Math.round(currentlyPainted / totalPainted * 1000) / 10;
         var logEntry = (_componentsLog$timest = componentsLog[timestamp]) === null || _componentsLog$timest === void 0 ? void 0 : _componentsLog$timest.map(function (v) {
           return v.targetName;
         });
+        var ratioDelta = (currentlyPaintedRatio - ((_acc$rel$vc = (_acc$rel = acc.rel[i - 1]) === null || _acc$rel === void 0 ? void 0 : _acc$rel.vc) !== null && _acc$rel$vc !== void 0 ? _acc$rel$vc : 0)) / 100;
+        if (isCalcSpeedIndexEnabled) {
+          var speedIndex = timestamp * ratioDelta;
+          acc.speedIndex += speedIndex;
+        }
         acc.abs.push([timestamp, currentlyPainted]);
         acc.rel.push({
           time: timestamp,
@@ -566,8 +668,10 @@ export var VCObserver = /*#__PURE__*/function () {
         return acc;
       }, {
         abs: [],
-        rel: []
+        rel: [],
+        speedIndex: 0
       });
+      VCEntries.speedIndex = Math.round(VCEntries.speedIndex);
       return {
         VC: VC,
         VCBox: VCBox,

package/dist/esm/vc/vc-observer/observers/ssr-placeholders/index.js

@@ -1,7 +1,6 @@
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import { fg } from '@atlaskit/platform-feature-flags';
 var EQUALITY_THRESHOLD = 0.1;
 var ANCESTOR_LOOKUP_LIMIT = 10;
 export var SSRPlaceholderHandlers = /*#__PURE__*/function () {
@@ -29,20 +28,15 @@ export var SSRPlaceholderHandlers = /*#__PURE__*/function () {
             return;
           }
           var rect = _this.staticPlaceholders.get(staticKey);
-          if (fg('platform_ufo_ssr_ttvc_use_target_rect')) {
-            var hasSameSizePosition = _this.hasSameSizePosition(rect, boundingClientRect);
-            if (hasSameSizePosition || _this.isDummyRect(rect)) {
-              _resolve(hasSameSizePosition);
-            } else {
-              requestAnimationFrame(function () {
-                var targetRect = target.getBoundingClientRect();
-                var hasSameSizePosition = _this.hasSameSizePosition(rect, targetRect);
-                _resolve(hasSameSizePosition);
-              });
-            }
+          var hasSameSizePosition = _this.hasSameSizePosition(rect, boundingClientRect);
+          if (hasSameSizePosition || _this.isDummyRect(rect)) {
+            _resolve(hasSameSizePosition);
           } else {
-            var _hasSameSizePosition = _this.hasSameSizePosition(rect, boundingClientRect);
-            _resolve(_hasSameSizePosition);
+            requestAnimationFrame(function () {
+              var targetRect = target.getBoundingClientRect();
+              var hasSameSizePosition = _this.hasSameSizePosition(rect, targetRect);
+              _resolve(hasSameSizePosition);
+            });
           }
           _this.callbacks.delete(staticKey);
         }
@@ -53,20 +47,15 @@ export var SSRPlaceholderHandlers = /*#__PURE__*/function () {
           return;
         }
         var _rect = _this.staticPlaceholders.get(key);
-        if (fg('platform_ufo_ssr_ttvc_use_target_rect')) {
-          var _hasSameSizePosition2 = _this.hasSameSizePosition(_rect, boundingClientRect);
-          if (_hasSameSizePosition2 || _this.isDummyRect(_rect)) {
-            _resolve2(_hasSameSizePosition2);
-          } else {
-            requestAnimationFrame(function () {
-              var targetRect = target.getBoundingClientRect();
-              var hasSameSizePosition = _this.hasSameSizePosition(_rect, targetRect);
-              _resolve2(hasSameSizePosition);
-            });
-          }
+        var _hasSameSizePosition = _this.hasSameSizePosition(_rect, boundingClientRect);
+        if (_hasSameSizePosition || _this.isDummyRect(_rect)) {
+          _resolve2(_hasSameSizePosition);
         } else {
-          var _hasSameSizePosition3 = _this.hasSameSizePosition(_rect, boundingClientRect);
-          _resolve2(_hasSameSizePosition3);
+          requestAnimationFrame(function () {
+            var targetRect = target.getBoundingClientRect();
+            var hasSameSizePosition = _this.hasSameSizePosition(_rect, targetRect);
+            _resolve2(hasSameSizePosition);
+          });
         }
         _this.staticPlaceholders.delete(staticKey);
         _this.reactValidateCallbacks.delete(staticKey);

package/dist/esm/vc/vc-observer/revisions/ViewportUpdateClassifier.js

@@ -0,0 +1,45 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+export var ViewportUpdateClassifier = /*#__PURE__*/function () {
+  function ViewportUpdateClassifier() {
+    _classCallCheck(this, ViewportUpdateClassifier);
+    _defineProperty(this, "types", []);
+    _defineProperty(this, "filters", []);
+    _defineProperty(this, "removedFilters", []);
+    _defineProperty(this, "__combinedTypes", []);
+    _defineProperty(this, "__combinedFilters", []);
+  }
+  return _createClass(ViewportUpdateClassifier, [{
+    key: "mergeConfig",
+    value: function mergeConfig() {
+      var _this = this;
+      this.__combinedTypes = [].concat(_toConsumableArray(this.types), _toConsumableArray((this === null || this === void 0 ? void 0 : this.__combinedTypes) || []));
+      var previousFilters = this.removedFilters.length === 0 ? this.__combinedFilters : this.__combinedFilters.filter(function (filter) {
+        return !_this.removedFilters.includes(filter.name);
+      });
+      this.__combinedFilters = [].concat(_toConsumableArray(this.filters), _toConsumableArray(previousFilters));
+    }
+  }, {
+    key: "classifyUpdate",
+    value: function classifyUpdate(_ref) {
+      var element = _ref.element,
+        type = _ref.type,
+        tags = _ref.tags,
+        ignoreReason = _ref.ignoreReason;
+      if (!this.__combinedTypes.includes(type)) {
+        return false;
+      }
+      return this.__combinedFilters.every(function (_ref2) {
+        var filter = _ref2.filter,
+          name = _ref2.name;
+        return filter({
+          type: type,
+          tags: tags,
+          ignoreReason: ignoreReason
+        });
+      });
+    }
+  }]);
+}();