@atlaskit/react-ufo 2.14.3 → 2.15.0

package/dist/cjs/vc/vc-observer/revisions/fy24_01.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.revFY24_01Classifier = exports.FY24_01Classifier = void 0;
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _ViewportUpdateClassifier = require("./ViewportUpdateClassifier");
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var legacyIgnoreReasons = ['image', 'ssr-hydration', 'editor-lazy-node-view', 'editor-container-mutation'];
+var FY24_01Classifier = exports.FY24_01Classifier = /*#__PURE__*/function (_ViewportUpdateClassi) {
+  function FY24_01Classifier() {
+    var _this;
+    (0, _classCallCheck2.default)(this, FY24_01Classifier);
+    _this = _callSuper(this, FY24_01Classifier);
+    (0, _defineProperty2.default)(_this, "revision", 'fy24.01');
+    (0, _defineProperty2.default)(_this, "types", ['html', 'text']);
+    (0, _defineProperty2.default)(_this, "filters", [{
+      name: 'default-ignore-reasons',
+      filter: function filter(_ref) {
+        var type = _ref.type,
+          ignoreReason = _ref.ignoreReason;
+        return !ignoreReason || !legacyIgnoreReasons.includes(ignoreReason);
+      }
+    }]);
+    _this.mergeConfig();
+    return _this;
+  }
+  (0, _inherits2.default)(FY24_01Classifier, _ViewportUpdateClassi);
+  return (0, _createClass2.default)(FY24_01Classifier);
+}(_ViewportUpdateClassifier.ViewportUpdateClassifier);
+var revFY24_01Classifier = exports.revFY24_01Classifier = new FY24_01Classifier();

package/dist/cjs/vc/vc-observer/revisions/fy25_01.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.revFY25_01Classifier = exports.FY25_01Classifier = void 0;
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _fy24_ = require("./fy24_01");
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var FY25_01Classifier = exports.FY25_01Classifier = /*#__PURE__*/function (_FY24_01Classifier) {
+  function FY25_01Classifier() {
+    var _this;
+    (0, _classCallCheck2.default)(this, FY25_01Classifier);
+    _this = _callSuper(this, FY25_01Classifier);
+    (0, _defineProperty2.default)(_this, "revision", 'fy25.01');
+    (0, _defineProperty2.default)(_this, "types", ['attr']);
+    (0, _defineProperty2.default)(_this, "filters", [{
+      name: 'not-visible',
+      filter: function filter(_ref) {
+        var type = _ref.type,
+          ignoreReason = _ref.ignoreReason;
+        return !(ignoreReason !== null && ignoreReason !== void 0 && ignoreReason.includes('not-visible'));
+      }
+    }]);
+    (0, _defineProperty2.default)(_this, "removedFilters", []);
+    _this.mergeConfig();
+    return _this;
+  }
+  (0, _inherits2.default)(FY25_01Classifier, _FY24_01Classifier);
+  return (0, _createClass2.default)(FY25_01Classifier);
+}(_fy24_.FY24_01Classifier);
+var revFY25_01Classifier = exports.revFY25_01Classifier = new FY25_01Classifier();

package/dist/cjs/vc/vc-observer/revisions/revisions.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getRevisions = void 0;
+var _fy24_ = require("./fy24_01");
+var _fy25_ = require("./fy25_01");
+var Revisions = [{
+  name: 'fy24.01',
+  classifier: _fy24_.revFY24_01Classifier
+}, {
+  name: 'fy25.01',
+  classifier: _fy25_.revFY25_01Classifier
+}];
+var revisionResultCache = null;
+var getRevisions = exports.getRevisions = function getRevisions() {
+  if (revisionResultCache !== null) {
+    return revisionResultCache;
+  }
+  revisionResultCache = [].concat(Revisions);
+  return revisionResultCache;
+};

package/dist/cjs/vc/vc-observer/revisions/types.js

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

package/dist/es2019/create-payload/index.js

@@ -201,6 +201,16 @@ const getVCMetrics = interaction => {
   if (interactionStatus.originalInteractionStatus !== 'SUCCEEDED' || pageVisibilityUpToTTAI !== 'visible') {
     return result;
   }
+  if (fg('ufo_vc_multiheatmap')) {
+    var _result;
+    (_result = result[`${prefix}:vc:rev`]) === null || _result === void 0 ? void 0 : _result.forEach(element => {
+      var _element$vcDetails, _element$vcDetails$;
+      if ((_element$vcDetails = element.vcDetails) !== null && _element$vcDetails !== void 0 && (_element$vcDetails$ = _element$vcDetails['90']) !== null && _element$vcDetails$ !== void 0 && _element$vcDetails$.t) {
+        var _element$vcDetails$2;
+        element['metric:vc90'] = (_element$vcDetails$2 = element.vcDetails['90']) === null || _element$vcDetails$2 === void 0 ? void 0 : _element$vcDetails$2.t;
+      }
+    });
+  }
   return {
     ...result,
     'metric:vc90': VC['90']

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

@@ -28,4 +28,8 @@ export const getActiveTraceHttpRequestHeaders = _url => {
     spanId
   } = state.context;
   return makeTraceHttpRequestHeaders(traceId, spanId);
+};
+export const getActiveTraceAsQueryParams = _url => {
+  const traceHeaders = getActiveTraceHttpRequestHeaders(_url);
+  return traceHeaders ? new URLSearchParams(traceHeaders).toString().toLowerCase() : null;
 };

package/dist/es2019/segment/segment.js

@@ -1,6 +1,7 @@
 import React, { lazy, Profiler, Suspense, useCallback, useContext, useEffect, useMemo, useRef } from 'react';
 import { unstable_NormalPriority as NormalPriority, unstable_scheduleCallback as scheduleCallback } from 'scheduler';
 import { v4 as createUUID } from 'uuid';
+import { fg } from '@atlaskit/platform-feature-flags';
 import coinflip from '../coinflip';
 import { getConfig, getInteractionRate } from '../config';
 import { getActiveTrace, setInteractionActiveTrace } from '../experience-trace-id-context';
@@ -31,7 +32,9 @@ export default function UFOSegment({
   }], [parentContext, segmentName, segmentId]);
   const interactionId = useContext(UFOInteractionIDContext);
   const interactionContext = useMemo(() => {
-    addSegment(labelStack);
+    if (!fg('platform-ufo-add-segment-use-effect')) {
+      addSegment(labelStack);
+    }
     let lastCompleteEndTime = 0;
     function complete(endTime = performance.now()) {
       if (interactionId.current) {
@@ -205,8 +208,13 @@ export default function UFOSegment({
       interactionContext.onRender(phase, actualDuration, baseDuration, startTime, commitTime);
     }
   }, [interactionContext]);
-  useEffect(() => () => {
-    removeSegment(labelStack);
+  useEffect(() => {
+    if (fg('platform-ufo-add-segment-use-effect')) {
+      addSegment(labelStack);
+    }
+    return () => {
+      removeSegment(labelStack);
+    };
   }, [interactionId, parentContext, interactionContext, labelStack]);
   const reactProfilerId = useMemo(() => labelStack.map(l => l.name).join('/'), [labelStack]);
   const enableSegmentHighlighting = (_getConfig2 = getConfig()) === null || _getConfig2 === void 0 ? void 0 : _getConfig2.enableSegmentHighlighting;

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

@@ -0,0 +1,238 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+const UNUSED_SECTOR = 0;
+export class MultiRevisionHeatmap {
+  constructor({
+    viewport,
+    revisions,
+    arraySize,
+    devToolsEnabled
+  }) {
+    _defineProperty(this, "arraySize", {
+      w: 200,
+      h: 200
+    });
+    _defineProperty(this, "mapPixelsToHeatmap", (left, top, width, height) => {
+      const {
+        w,
+        h
+      } = this.viewport;
+      const l = Math.floor(left / w * this.arraySize.w);
+      const t = Math.floor(top / h * this.arraySize.h);
+      const r = Math.ceil((left + width) / w * this.arraySize.w);
+      const b = Math.ceil((top + height) / h * this.arraySize.h);
+
+      // correct values to min - 0, max - arraySize
+      const 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", mappedValues => {
+      const {
+        r,
+        l,
+        b,
+        t
+      } = mappedValues;
+      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(({}, i) => {
+      this.heatmaps[i] = this.getCleanHeatmap();
+      this.componentsLogs[i] = {};
+      this.vcRatios[i] = {};
+    });
+  }
+  handleUpdate({
+    time,
+    type,
+    classification,
+    intersectionRect,
+    element,
+    targetName,
+    ignoreReason,
+    onError
+  }) {
+    const mappedValues = this.mapPixelsToHeatmap(intersectionRect.left, intersectionRect.top, intersectionRect.width, intersectionRect.height);
+    const result = this.applyChangesToHeatMap(mappedValues, time, classification);
+    if (result !== true) {
+      onError(result);
+    }
+    const componentRatio = this.getElementRatio(mappedValues);
+    this.revisions.forEach((_, i) => {
+      if (classification[i]) {
+        this.vcRatios[i][targetName] = componentRatio;
+      }
+      if (!this.componentsLogs[i][time]) {
+        this.componentsLogs[i][time] = [];
+      }
+      this.componentsLogs[i][time].push({
+        __debug__element: this.devToolsEnabled ? new WeakRef(element) : null,
+        intersectionRect,
+        targetName,
+        ignoreReason
+      });
+    });
+  }
+  getData() {
+    return {
+      heatmaps: this.heatmaps
+    };
+  }
+  getPayloadShapedData(args) {
+    const result = this.processData(args);
+    const payload = this.revisions.map((rev, i) => {
+      const vcDetails = {};
+      args.VCParts.forEach(VCPart => {
+        vcDetails[VCPart] = {
+          t: result[i].VC[VCPart] || 0,
+          e: Array.from(result[i].VCBox[VCPart] || [])
+        };
+      });
+      return {
+        revision: rev.name,
+        vcDetails,
+        clean: args.clean,
+        'metric:vc90': null // will be set or not in the payload generator
+      };
+    });
+    return payload;
+  }
+  processData({
+    VCParts,
+    ssr = UNUSED_SECTOR
+  }) {
+    return this.heatmaps.map((heatmap, i) => {
+      const lastUpdate = {};
+      let totalPainted = 0;
+      let componentsLog = this.componentsLogs[i];
+      if (ssr !== UNUSED_SECTOR) {
+        var _window$document;
+        const 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: this.viewport.w,
+            height: this.viewport.h,
+            toJSON() {
+              return {};
+            }
+          },
+          targetName: 'SSR'
+        };
+        if (!componentsLog[ssr]) {
+          componentsLog[ssr] = [];
+        }
+        componentsLog[ssr].push(element);
+      }
+      for (let i = 0; i < heatmap.length; i++) {
+        const 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;
+        }
+      }
+      const entries = Object.entries(lastUpdate).map(a => [parseInt(a[0], 10), a[1]]).sort((a, b) => a[0] > b[0] ? 1 : -1);
+      const VC = MultiRevisionHeatmap.makeVCReturnObj(VCParts);
+      const VCBox = MultiRevisionHeatmap.makeVCReturnObj(VCParts);
+      entries.reduce((acc = 0, v) => {
+        const VCRatio = v[1] / totalPainted + acc;
+        const time = v[0];
+        VCParts.forEach(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 ? void 0 : _componentsLog$time.forEach(v => {
+              var _VCBox$value;
+              return (_VCBox$value = VCBox[value]) === null || _VCBox$value === void 0 ? void 0 : _VCBox$value.add(v.targetName);
+            });
+          }
+        });
+        return VCRatio;
+      }, 0);
+      const VCEntries = entries.reduce((acc, [timestamp, entryPainted], i) => {
+        var _acc$abs, _componentsLog$timest;
+        const currentlyPainted = entryPainted + (((_acc$abs = acc.abs[i - 1]) === null || _acc$abs === void 0 ? void 0 : _acc$abs[1]) || 0);
+        const currentlyPaintedRatio = Math.round(currentlyPainted / totalPainted * 1000) / 10;
+        const logEntry = (_componentsLog$timest = componentsLog[timestamp]) === null || _componentsLog$timest === void 0 ? void 0 : _componentsLog$timest.map(v => v.targetName);
+        acc.abs.push([timestamp, currentlyPainted]);
+        acc.rel.push({
+          time: timestamp,
+          vc: currentlyPaintedRatio,
+          elements: logEntry
+        });
+        return acc;
+      }, {
+        abs: [],
+        rel: []
+      });
+      return {
+        VC,
+        VCBox,
+        VCEntries,
+        totalPainted
+      };
+    });
+  }
+  applyChangesToHeatMap(a, time, classification) {
+    const {
+      l,
+      t,
+      r,
+      b
+    } = a;
+    const size = classification.length;
+    for (let row = t; row < b; row++) {
+      if (this.heatmaps[0][row] === undefined) {
+        try {
+          return {
+            error: `index - ${row}`,
+            time
+          };
+        } catch (e) {
+          return {
+            error: 'row error',
+            time
+          };
+        }
+      } else {
+        for (let heatmapIndex = 0; heatmapIndex < size; heatmapIndex++) {
+          if (classification[heatmapIndex]) {
+            this.heatmaps[heatmapIndex].fill(time, this.getIndex(l, row), this.getIndex(r, row));
+          }
+        }
+      }
+    }
+    return true;
+  }
+  getIndex(x, y) {
+    return x + this.arraySize.w * y;
+  }
+  getCleanHeatmap() {
+    return new Uint32Array(this.arraySize.w * this.arraySize.h);
+  }
+  static makeVCReturnObj(VCParts) {
+    const vc = {};
+    VCParts.forEach(v => {
+      vc[v] = null;
+    });
+    return vc;
+  }
+}

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

@@ -2,7 +2,9 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 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';
 const abortReason = {
   scroll: 'scroll',
   keypress: 'keypress',
@@ -35,6 +37,7 @@ export class VCObserver {
     });
     /* heatmap */
     _defineProperty(this, "arraySize", 0);
+    _defineProperty(this, "multiHeatmap", null);
     _defineProperty(this, "componentsLog", {});
     _defineProperty(this, "vcRatios", {});
     _defineProperty(this, "active", false);
@@ -68,6 +71,7 @@ export class VCObserver {
         },
         heatmap: this.heatmap,
         heatmapNext: this.heatmapNext,
+        multiHeatmap: this.multiHeatmap,
         outOfBoundaryInfo: this.outOfBoundaryInfo,
         totalTime: Math.round(this.totalTime + this.observers.getTotalTime()),
         componentsLog: {
@@ -106,7 +110,8 @@ export class VCObserver {
         componentsLog,
         viewport,
         devToolsEnabled,
-        ratios
+        ratios,
+        multiHeatmap
       } = rawData;
       if (abortReasonInfo !== null && abortReason.blocking) {
         // exposing data to devtools
@@ -150,6 +155,7 @@ export class VCObserver {
         /* empty */
       }
       let _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(([_timestamp, value]) => {
           const timestamp = Number(_timestamp);
@@ -207,9 +213,30 @@ export class VCObserver {
               tti,
               ttai: stop - start
             },
+            start,
+            stop,
             heatmap,
             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,
+              ttai: stop - start
+            },
+            start,
+            stop,
+            heatmap: heatmapNext,
+            ratios
+          };
 
           // Emitting a custom event to make it available in the Chrome extension
           window.dispatchEvent(new CustomEvent('vcReady', {
@@ -222,6 +249,15 @@ export class VCObserver {
       } catch (e) {
         /*  do nothing */
       }
+      const isMultiHeatmapEnabled = fg('ufo_vc_multiheatmap');
+      const revisionsData = isMultiHeatmapEnabled && multiHeatmap !== null ? {
+        [`${fullPrefix}vc:rev`]: multiHeatmap.getPayloadShapedData({
+          VCParts: VCObserver.VCParts.map(v => parseInt(v)),
+          ssr,
+          clean: !abortReasonInfo
+        })
+      } : null;
+      // eslint-disable-next-line @atlaskit/platform/ensure-feature-flag-prefix
       const isCalcSpeedIndexEnabled = fg('ufo-calc-speed-index');
       return {
         'metrics:vc': VC,
@@ -240,12 +276,27 @@ export class VCObserver {
         [`${fullPrefix}vc:next:dom`]: vcNext.VCBox,
         //...oldDomUpdates,
         [`${fullPrefix}vc:ignored`]: this.getIgnoredElements(componentsLog),
+        ...revisionsData,
         [`ufo:speedIndex`]: isCalcSpeedIndexEnabled ? VCEntries.speedIndex : undefined,
         [`ufo:next:speedIndex`]: isCalcSpeedIndexEnabled ? vcNext.VCEntries.speedIndex : undefined
       };
     });
     _defineProperty(this, "handleUpdate", (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,
+          targetName,
+          element,
+          type,
+          ignoreReason
+        });
+      }
+      this.measureStop();
+    });
+    _defineProperty(this, "legacyHandleUpdate", (rawTime, intersectionRect, targetName, element, type, ignoreReason) => {
       if (this.abortReason.reason === null || this.abortReason.blocking === false) {
         const time = Math.round(rawTime - this.startTime);
         const mappedValues = this.mapPixelsToHeatmap(intersectionRect.left, intersectionRect.top, intersectionRect.width, intersectionRect.height);
@@ -266,8 +317,39 @@ export class VCObserver {
           ignoreReason
         });
       }
-      // devtools export
-      this.measureStop();
+    });
+    _defineProperty(this, "onViewportChangeDetected", ({
+      element,
+      type,
+      ignoreReason,
+      timestamp,
+      targetName,
+      intersectionRect
+    }) => {
+      if (this.multiHeatmap === null) {
+        return;
+      }
+      // @todo add abort reason handling
+      const time = Math.round(timestamp - this.startTime);
+      const revisions = getRevisions();
+      const revisionsClassification = revisions.map(revision => {
+        return revision.classifier.classifyUpdate({
+          element,
+          type,
+          ignoreReason
+        });
+      }, []);
+      this.multiHeatmap.handleUpdate({
+        time,
+        targetName,
+        intersectionRect,
+        type,
+        element,
+        classification: revisionsClassification,
+        onError: error => {
+          this.setAbortReason(abortReason.error, error.time, error.error);
+        }
+      });
     });
     _defineProperty(this, "mapPixelsToHeatmap", (left, top, width, height) => {
       const {
@@ -352,6 +434,13 @@ export class VCObserver {
     });
     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;
   }
   start({
@@ -428,6 +517,8 @@ export class VCObserver {
     const entries = Object.entries(lastUpdate).map(a => [parseInt(a[0], 10), a[1]]).sort((a, b) => a[0] > b[0] ? 1 : -1);
     const VC = VCObserver.makeVCReturnObj();
     const VCBox = VCObserver.makeVCReturnObj();
+
+    // eslint-disable-next-line @atlaskit/platform/ensure-feature-flag-prefix
     const isCalcSpeedIndexEnabled = fg('ufo-calc-speed-index');
     entries.reduce((acc = 0, v) => {
       const currRatio = v[1] / totalPainted;

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

@@ -0,0 +1,35 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+export class ViewportUpdateClassifier {
+  constructor() {
+    _defineProperty(this, "types", []);
+    _defineProperty(this, "filters", []);
+    _defineProperty(this, "removedFilters", []);
+    _defineProperty(this, "__combinedTypes", []);
+    _defineProperty(this, "__combinedFilters", []);
+  }
+  mergeConfig() {
+    this.__combinedTypes = [...this.types, ...((this === null || this === void 0 ? void 0 : this.__combinedTypes) || [])];
+    const previousFilters = this.removedFilters.length === 0 ? this.__combinedFilters : this.__combinedFilters.filter(filter => !this.removedFilters.includes(filter.name));
+    this.__combinedFilters = [...this.filters, ...previousFilters];
+  }
+  classifyUpdate({
+    element,
+    type,
+    tags,
+    ignoreReason
+  }) {
+    if (!this.__combinedTypes.includes(type)) {
+      return false;
+    }
+    return this.__combinedFilters.every(({
+      filter,
+      name
+    }) => {
+      return filter({
+        type,
+        tags,
+        ignoreReason
+      });
+    });
+  }
+}

package/dist/es2019/vc/vc-observer/revisions/fy24_01.js

@@ -0,0 +1,21 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { ViewportUpdateClassifier } from './ViewportUpdateClassifier';
+const legacyIgnoreReasons = ['image', 'ssr-hydration', 'editor-lazy-node-view', 'editor-container-mutation'];
+export class FY24_01Classifier extends ViewportUpdateClassifier {
+  constructor() {
+    super();
+    _defineProperty(this, "revision", 'fy24.01');
+    _defineProperty(this, "types", ['html', 'text']);
+    _defineProperty(this, "filters", [{
+      name: 'default-ignore-reasons',
+      filter: ({
+        type,
+        ignoreReason
+      }) => {
+        return !ignoreReason || !legacyIgnoreReasons.includes(ignoreReason);
+      }
+    }]);
+    this.mergeConfig();
+  }
+}
+export const revFY24_01Classifier = new FY24_01Classifier();

package/dist/es2019/vc/vc-observer/revisions/fy25_01.js

@@ -0,0 +1,21 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { FY24_01Classifier } from './fy24_01';
+export class FY25_01Classifier extends FY24_01Classifier {
+  constructor() {
+    super();
+    _defineProperty(this, "revision", 'fy25.01');
+    _defineProperty(this, "types", ['attr']);
+    _defineProperty(this, "filters", [{
+      name: 'not-visible',
+      filter: ({
+        type,
+        ignoreReason
+      }) => {
+        return !(ignoreReason !== null && ignoreReason !== void 0 && ignoreReason.includes('not-visible'));
+      }
+    }]);
+    _defineProperty(this, "removedFilters", []);
+    this.mergeConfig();
+  }
+}
+export const revFY25_01Classifier = new FY25_01Classifier();