@atlaskit/react-ufo 3.4.14 → 3.5.1

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

@@ -1,5 +1,5 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import { fg } from '@atlaskit/platform-feature-flags';
+import { markProfilingEnd, markProfilingStart, withProfiling } from '../../../../self-measurements';
 const ANCESTOR_LOOKUP_LIMIT = 10;
 export class SSRPlaceholderHandlers {
   constructor() {
@@ -7,7 +7,7 @@ export class SSRPlaceholderHandlers {
     _defineProperty(this, "callbacks", new Map());
     _defineProperty(this, "getSizeCallbacks", new Map());
     _defineProperty(this, "reactValidateCallbacks", new Map());
-    _defineProperty(this, "EQUALITY_THRESHOLD", fg('platform_ufo_ssr_placeholder_round_rect_size_check') ? 1 : 0.1);
+    _defineProperty(this, "EQUALITY_THRESHOLD", 1);
     _defineProperty(this, "intersectionObserverCallback", ({
       target,
       boundingClientRect
@@ -60,6 +60,7 @@ export class SSRPlaceholderHandlers {
         this.reactValidateCallbacks.delete(staticKey);
       }
     });
+    const operationTimer = markProfilingStart('SSRPlaceholderHandlers constructor');
     if (typeof IntersectionObserver === 'function') {
       // Only instantiate the IntersectionObserver if it's supported
       this.intersectionObserver = new IntersectionObserver(entries => entries.filter(entry => entry.intersectionRatio > 0).forEach(this.intersectionObserverCallback));
@@ -95,6 +96,20 @@ export class SSRPlaceholderHandlers {
         delete window.__SSR_PLACEHOLDERS_DIMENSIONS__;
       }
     }
+    this.clear = withProfiling(this.clear.bind(this), ['vc']);
+    this.isPlaceholder = withProfiling(this.isPlaceholder.bind(this), ['vc']);
+    this.isPlaceholderReplacement = withProfiling(this.isPlaceholderReplacement.bind(this), ['vc']);
+    this.isPlaceholderIgnored = withProfiling(this.isPlaceholderIgnored.bind(this), ['vc']);
+    this.findNearestPlaceholderContainerIfIgnored = withProfiling(this.findNearestPlaceholderContainerIfIgnored.bind(this), ['vc']);
+    this.checkIfExistedAndSizeMatching = withProfiling(this.checkIfExistedAndSizeMatching.bind(this), ['vc']);
+    this.getSize = withProfiling(this.getSize.bind(this), ['vc']);
+    this.validateReactComponentMatchToPlaceholder = withProfiling(this.validateReactComponentMatchToPlaceholder.bind(this), ['vc']);
+    this.hasSameSizePosition = withProfiling(this.hasSameSizePosition.bind(this), ['vc']);
+    this.isDummyRect = withProfiling(this.isDummyRect.bind(this), ['vc']);
+    this.intersectionObserverCallback = withProfiling(this.intersectionObserverCallback.bind(this), ['vc']);
+    markProfilingEnd(operationTimer, {
+      tags: ['vc']
+    });
   }
   clear() {
     this.staticPlaceholders = new Map();

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

@@ -1,5 +1,5 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import { fg } from '@atlaskit/platform-feature-flags';
+import { withProfiling } from '../../../self-measurements';
 import { ViewportUpdateClassifier } from './ViewportUpdateClassifier';
 const legacyIgnoreReasons = ['image', 'ssr-hydration', 'editor-lazy-node-view', 'editor-container-mutation'];
 export class FY25_01Classifier extends ViewportUpdateClassifier {
@@ -14,12 +14,11 @@ export class FY25_01Classifier extends ViewportUpdateClassifier {
     entries.reduce((acc = 0, v) => {
       let VCRatio = v[1] / totalPainted + acc;
       const time = v[0];
-      if (fg('platform_ufo_fix_vc_observer_rounding_error')) {
-        // @todo apply fix to include small changes into accumulator
-        const preciseCurrRatio = Math.round(100 * (v[1] / totalPainted));
-        const preciseAccRatio = Math.round(acc * 100);
-        VCRatio = (preciseCurrRatio + preciseAccRatio) / 100;
-      }
+
+      // @todo apply fix to include small changes into accumulator
+      const preciseCurrRatio = Math.round(100 * (v[1] / totalPainted));
+      const preciseAccRatio = Math.round(acc * 100);
+      VCRatio = (preciseCurrRatio + preciseAccRatio) / 100;
       VCParts.forEach(value => {
         if ((VC[value] === null || VC[value] === undefined) && VCRatio >= value / 100) {
           var _componentsLog$time;
@@ -52,6 +51,7 @@ export class FY25_01Classifier extends ViewportUpdateClassifier {
       }
     }]);
     this.mergeConfig();
+    this.VCCalculationMethod = withProfiling(this.VCCalculationMethod.bind(this), ['vc']);
   }
 }
 export const revFY25_01Classifier = new FY25_01Classifier();

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

@@ -1,4 +1,5 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { withProfiling } from '../../../self-measurements';
 import { FY25_01Classifier } from './fy25_01';
 export class FY25_02Classifier extends FY25_01Classifier {
   // @todo remove it once fixed as described: https://product-fabric.atlassian.net/browse/AFO-3443
@@ -30,6 +31,7 @@ export class FY25_02Classifier extends FY25_01Classifier {
     }]);
     _defineProperty(this, "removedFilters", []);
     this.mergeConfig();
+    this.filterComponentsLog = withProfiling(this.filterComponentsLog.bind(this), ['vc']);
   }
 }
 export const revFY25_02Classifier = new FY25_02Classifier();

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

@@ -1,7 +1,8 @@
 import { fg } from '@atlaskit/platform-feature-flags';
+import { withProfiling } from '../../../self-measurements';
 import { revFY25_01Classifier } from './fy25_01';
 import { revFY25_02Classifier } from './fy25_02';
-export const getRevisions = () => {
+export const getRevisions = withProfiling(function getRevisions() {
   if (fg('platform_ufo_disable_ttvc_v1')) {
     return [{
       name: 'fy25.02',
@@ -15,4 +16,4 @@ export const getRevisions = () => {
     name: 'fy25.02',
     classifier: revFY25_02Classifier
   }];
-};
+}, ['vc']);

package/dist/es2019/vc/vc-observer-new/entries-timeline/index.js

@@ -1,9 +1,18 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { markProfilingEnd, markProfilingStart, withProfiling } from '../../../self-measurements';
 export default class EntriesTimeline {
   constructor() {
     _defineProperty(this, "unorderedEntries", []);
     _defineProperty(this, "sortedEntriesCache", new Map());
+    const operationTimer = markProfilingStart('EntriesTimeline constructor');
     this.unorderedEntries = [];
+    this.push = withProfiling(this.push.bind(this), ['vc']);
+    this.getCacheKey = withProfiling(this.getCacheKey.bind(this), ['vc']);
+    this.getOrderedEntries = withProfiling(this.getOrderedEntries.bind(this), ['vc']);
+    this.clear = withProfiling(this.clear.bind(this), ['vc']);
+    markProfilingEnd(operationTimer, {
+      tags: ['vc']
+    });
   }
   push(entry) {
     this.unorderedEntries.push(entry);

package/dist/es2019/vc/vc-observer-new/get-element-name.js

@@ -1,5 +1,6 @@
+import { withProfiling } from '../../self-measurements';
 const nameCache = new WeakMap();
-export default function getElementName(selectorConfig, element) {
+const getElementName = withProfiling(function getElementName(selectorConfig, element) {
   if (!(element instanceof HTMLElement)) {
     return 'error';
   }
@@ -64,4 +65,5 @@ export default function getElementName(selectorConfig, element) {
   const name = `${tagName}${attributes || classList}`;
   nameCache.set(element, name);
   return name;
-}
+}, ['vc']);
+export default getElementName;

package/dist/es2019/vc/vc-observer-new/get-unique-element-name.js

@@ -1,23 +1,24 @@
+import { withProfiling } from '../../self-measurements';
 const nameCache = new WeakMap();
-function getAttributeSelector(element, attributeName) {
+const getAttributeSelector = withProfiling(function getAttributeSelector(element, attributeName) {
   const attrValue = element.getAttribute(attributeName);
   if (!attrValue) {
     return '';
   }
   return `[${attributeName}="${attrValue}"]`;
-}
-function isValidSelector(selector) {
+}, ['vc']);
+const isValidSelector = withProfiling(function isValidSelector(selector) {
   try {
     document.querySelector(selector);
     return true;
   } catch (err) {
     return false;
   }
-}
-function isSelectorUnique(selector) {
+}, ['vc']);
+const isSelectorUnique = withProfiling(function isSelectorUnique(selector) {
   return document.querySelectorAll(selector).length === 1;
-}
-function getUniqueSelector(selectorConfig, element) {
+}, ['vc']);
+const getUniqueSelector = withProfiling(function getUniqueSelector(selectorConfig, element) {
   let currentElement = element;
   const parts = [];
   const MAX_DEPTH = 3;
@@ -59,8 +60,8 @@ function getUniqueSelector(selectorConfig, element) {
     }
   }
   return potentialSelector;
-}
-export default function getElementName(selectorConfig, element) {
+}, ['vc']);
+const getElementName = withProfiling(function getElementName(selectorConfig, element) {
   if (!(element instanceof HTMLElement)) {
     return 'error';
   }
@@ -71,4 +72,5 @@ export default function getElementName(selectorConfig, element) {
   const uniqueSelector = getUniqueSelector(selectorConfig, element);
   nameCache.set(element, uniqueSelector);
   return uniqueSelector;
-}
+}, ['vc']);
+export default getElementName;

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

@@ -1,4 +1,5 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { markProfilingEnd, markProfilingStart, withProfiling } from '../../self-measurements';
 import EntriesTimeline from './entries-timeline';
 import getElementName from './get-element-name';
 import VCCalculator_FY25_03 from './metric-calculator/fy25_03';
@@ -16,6 +17,7 @@ export default class VCObserverNew {
     var _config$selectorConfi;
     _defineProperty(this, "viewportObserver", null);
     _defineProperty(this, "windowEventObserver", null);
+    const operationTimer = markProfilingStart('VCObserverNew constructor');
     this.entriesTimeline = new EntriesTimeline();
     this.selectorConfig = (_config$selectorConfi = config.selectorConfig) !== null && _config$selectorConfi !== void 0 ? _config$selectorConfi : DEFAULT_SELECTOR_CONFIG;
     this.viewportObserver = new ViewportObserver({
@@ -61,6 +63,13 @@ export default class VCObserverNew {
         });
       }
     });
+    this.start = withProfiling(this.start.bind(this), ['vc']);
+    this.stop = withProfiling(this.stop.bind(this), ['vc']);
+    this.getVCResult = withProfiling(this.getVCResult.bind(this), ['vc']);
+    this.getElementName = withProfiling(this.getElementName.bind(this), ['vc']);
+    markProfilingEnd(operationTimer, {
+      tags: ['vc']
+    });
   }
   start({
     startTime

package/dist/es2019/vc/vc-observer-new/metric-calculator/abstract-base-vc-calculator.js

@@ -1,9 +1,11 @@
+import { withProfiling } from '../../../self-measurements';
 import calculateTTVCPercentiles from './percentile-calc';
 import getViewportHeight from './utils/get-viewport-height';
 import getViewportWidth from './utils/get-viewport-width';
 export default class AbstractVCCalculatorBase {
   constructor(revisionNo) {
     this.revisionNo = revisionNo;
+    this.calculate = withProfiling(this.calculate.bind(this), ['vc']);
   }
   async calculate({
     startTime,

package/dist/es2019/vc/vc-observer-new/metric-calculator/fy25_03/index.js

@@ -1,3 +1,4 @@
+import { withProfiling } from '../../../../self-measurements';
 import AbstractVCCalculatorBase from '../abstract-base-vc-calculator';
 import isViewportEntryData from '../utils/is-viewport-entry-data';
 const ABORTING_WINDOW_EVENT = ['wheel', 'scroll', 'keydown', 'resize'];
@@ -11,6 +12,8 @@ export const KNOWN_ATTRIBUTES_THAT_DOES_NOT_CAUSE_LAYOUT_SHIFTS = ['data-drop-ta
 export default class VCCalculator_FY25_03 extends AbstractVCCalculatorBase {
   constructor() {
     super(REVISION_NO);
+    this.isEntryIncluded = withProfiling(this.isEntryIncluded.bind(this), ['vc']);
+    this.isVCClean = withProfiling(this.isVCClean.bind(this), ['vc']);
   }
   isEntryIncluded(entry) {
     if (!CONSIDERED_ENTRY_TYPE.includes(entry.type)) {

package/dist/es2019/vc/vc-observer-new/metric-calculator/percentile-calc/canvas-heatmap/canvas-pixel.js

@@ -1,3 +1,4 @@
+import { markProfilingEnd, markProfilingStart, withProfiling } from '../../../../../self-measurements';
 import taskYield from '../../utils/task-yield';
 
 // 24-bit color value
@@ -25,6 +26,7 @@ export class ViewportCanvas {
    * @throws {Error} If canvas context cannot be obtained
    */
   constructor(viewport, scaleFactor = 1) {
+    const operationTimer = markProfilingStart('ViewportCanvas constructor');
     this.scaleFactor = scaleFactor;
     this.colorCounter = 1;
     this.colorTimeMap = new Map();
@@ -54,6 +56,14 @@ export class ViewportCanvas {
     this.ctx = ctx;
     this.ctx.globalCompositeOperation = 'source-over';
     this.clear();
+    this.getScaledDimensions = withProfiling(this.getScaledDimensions.bind(this), ['vc']);
+    this.clear = withProfiling(this.clear.bind(this), ['vc']);
+    this.generateColor = withProfiling(this.generateColor.bind(this), ['vc']);
+    this.drawRect = withProfiling(this.drawRect.bind(this), ['vc']);
+    this.getPixelCounts = withProfiling(this.getPixelCounts.bind(this), ['vc']);
+    markProfilingEnd(operationTimer, {
+      tags: ['vc']
+    });
   }
   getScaledDimensions() {
     return {
@@ -148,7 +158,7 @@ export class ViewportCanvas {
  * @param number - The input number to be split into RGB components.
  * @returns The RGB color string in the format "rgb(r, g, b)".
  */
-export function getRGBComponents(n) {
+export const getRGBComponents = withProfiling(function getRGBComponents(n) {
   // Ensure the input is within the valid range for a 24-bit color
   if (n < 0 || n > 0xffffff) {
     throw new Error('Input number must be between 0 and 16777215 (inclusive).');
@@ -163,7 +173,7 @@ export function getRGBComponents(n) {
   // Extract red component (bits 16-23)
   const red = n >> 16 & 0xff;
   return `rgb(${red}, ${green}, ${blue})`;
-}
+}, ['vc']);
 
 /**
  * Calculates the number of pixels drawn for each color in the image data.
@@ -172,7 +182,7 @@ export function getRGBComponents(n) {
  * @param arraySize - The amount of timestamps that were drawn in the viewport
  * @returns A Map containing color to pixel count mappings.
  */
-export async function calculateDrawnPixelsRaw(imageData, scaleFactor, arraySize) {
+export const calculateDrawnPixelsRaw = withProfiling(async function calculateDrawnPixelsRaw(imageData, scaleFactor, arraySize) {
   const data = imageData.data;
   const arr = new Uint32Array(arraySize);
   for (let i = 0; i < data.length; i += 4) {
@@ -192,4 +202,4 @@ export async function calculateDrawnPixelsRaw(imageData, scaleFactor, arraySize)
     }
   }
   return arr;
-}
+}, ['vc']);

package/dist/es2019/vc/vc-observer-new/metric-calculator/percentile-calc/canvas-heatmap/index.js

@@ -1,6 +1,7 @@
 import { fg } from '@atlaskit/platform-feature-flags';
+import { withProfiling } from '../../../../../self-measurements';
 import { ViewportCanvas } from './canvas-pixel';
-export default async function calculateTTVCPercentiles({
+const calculateTTVCPercentiles = withProfiling(async function calculateTTVCPercentiles({
   viewport,
   orderedEntries,
   percentiles,
@@ -26,8 +27,9 @@ export default async function calculateTTVCPercentiles({
   const canvasDimenstions = canvas.getScaledDimensions();
   const totalPixels = canvasDimenstions.width * canvasDimenstions.height;
   return calculatePercentiles(timePixelCounts, elementMap, percentiles, totalPixels, startTime);
-}
-export function calculatePercentiles(timePixelCounts, elementMap, unorderedPercentiles, totalPixels, startTime) {
+}, ['vc']);
+export default calculateTTVCPercentiles;
+export const calculatePercentiles = withProfiling(function calculatePercentiles(timePixelCounts, elementMap, unorderedPercentiles, totalPixels, startTime) {
   const results = {};
   let cumulativePixels = 0;
   const percentiles = unorderedPercentiles.sort((a, b) => a - b);
@@ -69,4 +71,4 @@ export function calculatePercentiles(timePixelCounts, elementMap, unorderedPerce
     previousResult = results[`${percentile}`];
   }
   return results;
-}
+}, ['vc']);

package/dist/es2019/vc/vc-observer-new/metric-calculator/percentile-calc/heatmap/heatmap.js

@@ -1,27 +1,28 @@
+import { markProfilingEnd, markProfilingStart, withProfiling } from '../../../../../self-measurements';
 import isViewportEntryData from '../../utils/is-viewport-entry-data';
 import taskYield from '../../utils/task-yield';
 const MAX_HEATMAP_SIZE = 1000;
-function createEmptyHeatmapEntry() {
+const createEmptyHeatmapEntry = withProfiling(function createEmptyHeatmapEntry() {
   return {
     head: null,
     previousEntries: []
   };
-}
-function createEmptyMap(heatmapWidth, heatmapHeight) {
+}, ['vc']);
+const createEmptyMap = withProfiling(function createEmptyMap(heatmapWidth, heatmapHeight) {
   return Array.from({
     length: heatmapHeight
   }).map(() => Array.from({
     length: heatmapWidth
   }).map(createEmptyHeatmapEntry));
-}
-function isRectInside(a, b) {
+}, ['vc']);
+const isRectInside = withProfiling(function isRectInside(a, b) {
   if (!a || !b) {
     return false;
   }
 
   // Check if all corners of rectangle a are within the bounds of rectangle b
   return a.left >= b.left && a.right <= b.right && a.top >= b.top && a.bottom <= b.bottom;
-}
+}, ['vc']);
 export default class Heatmap {
   /**
    * Heatmap Width
@@ -39,6 +40,8 @@ export default class Heatmap {
     viewport,
     heatmapSize
   }) {
+    const operationTimer = markProfilingStart('Heatmap constructor');
+
     // TODO timeOrigin? do we need? for SSR??
     this.viewport = viewport;
     const safeSize = Math.min(heatmapSize, MAX_HEATMAP_SIZE);
@@ -65,6 +68,15 @@ export default class Heatmap {
     this.scaleY = this.height / viewport.height;
     this.heatmapAreaSize = this.width * this.height;
     this.map = createEmptyMap(this.width, this.height);
+    this.getHeatmap = withProfiling(this.getHeatmap.bind(this), ['vc']);
+    this.getCell = withProfiling(this.getCell.bind(this), ['vc']);
+    this.mapDOMRectToHeatmap = withProfiling(this.mapDOMRectToHeatmap.bind(this), ['vc']);
+    this.getRatio = withProfiling(this.getRatio.bind(this), ['vc']);
+    this.applyEntriesToHeatmap = withProfiling(this.applyEntriesToHeatmap.bind(this), ['vc']);
+    this.getVCPercentMetrics = withProfiling(this.getVCPercentMetrics.bind(this), ['vc']);
+    markProfilingEnd(operationTimer, {
+      tags: ['vc']
+    });
   }
   getHeatmap() {
     return this.map;

package/dist/es2019/vc/vc-observer-new/metric-calculator/percentile-calc/heatmap/index.js

@@ -1,27 +1,28 @@
+import { markProfilingEnd, markProfilingStart, withProfiling } from '../../../../../self-measurements';
 import isViewportEntryData from '../../utils/is-viewport-entry-data';
 import taskYield from '../../utils/task-yield';
 const MAX_HEATMAP_SIZE = 1000;
-function createEmptyHeatmapEntry() {
+const createEmptyHeatmapEntry = withProfiling(function createEmptyHeatmapEntry() {
   return {
     head: null,
     previousEntries: []
   };
-}
-function createEmptyMap(heatmapWidth, heatmapHeight) {
+}, ['vc']);
+const createEmptyMap = withProfiling(function createEmptyMap(heatmapWidth, heatmapHeight) {
   return Array.from({
     length: heatmapHeight
   }).map(() => Array.from({
     length: heatmapWidth
   }).map(createEmptyHeatmapEntry));
-}
-function isRectInside(a, b) {
+}, ['vc']);
+const isRectInside = withProfiling(function isRectInside(a, b) {
   if (!a || !b) {
     return false;
   }
 
   // Check if all corners of rectangle a are within the bounds of rectangle b
   return a.left >= b.left && a.right <= b.right && a.top >= b.top && a.bottom <= b.bottom;
-}
+}, ['vc']);
 class Heatmap {
   /**
    * Heatmap Width
@@ -39,6 +40,8 @@ class Heatmap {
     viewport,
     heatmapSize
   }) {
+    const operationTimer = markProfilingStart('Heatmap constructor');
+
     // TODO timeOrigin? do we need? for SSR??
     this.viewport = viewport;
     const safeSize = Math.min(heatmapSize, MAX_HEATMAP_SIZE);
@@ -65,6 +68,15 @@ class Heatmap {
     this.scaleY = this.height / viewport.height;
     this.heatmapAreaSize = this.width * this.height;
     this.map = createEmptyMap(this.width, this.height);
+    this.getHeatmap = withProfiling(this.getHeatmap.bind(this), ['vc']);
+    this.getCell = withProfiling(this.getCell.bind(this), ['vc']);
+    this.mapDOMRectToHeatmap = withProfiling(this.mapDOMRectToHeatmap.bind(this), ['vc']);
+    this.getRatio = withProfiling(this.getRatio.bind(this), ['vc']);
+    this.applyEntriesToHeatmap = withProfiling(this.applyEntriesToHeatmap.bind(this), ['vc']);
+    this.getVCPercentMetrics = withProfiling(this.getVCPercentMetrics.bind(this), ['vc']);
+    markProfilingEnd(operationTimer, {
+      tags: ['vc']
+    });
   }
   getHeatmap() {
     return this.map;
@@ -246,7 +258,7 @@ class Heatmap {
     return result;
   }
 }
-export default async function calculateTTVCPercentiles({
+const calculateTTVCPercentiles = withProfiling(async function calculateTTVCPercentiles({
   orderedEntries,
   viewport,
   percentiles,
@@ -259,4 +271,5 @@ export default async function calculateTTVCPercentiles({
   await heatmap.applyEntriesToHeatmap(orderedEntries);
   const vcDetails = await heatmap.getVCPercentMetrics(percentiles, startTime);
   return vcDetails;
-}
+}, ['vc']);
+export default calculateTTVCPercentiles;

package/dist/es2019/vc/vc-observer-new/metric-calculator/percentile-calc/index.js

@@ -1,7 +1,8 @@
+import { withProfiling } from '../../../../self-measurements';
 import calcUsingCanvas from './canvas-heatmap';
 import caclUsingOldHeatmap from './heatmap';
 import calcUsingRectSweepingLine from './rect-sweeping-line';
-export default async function calculateTTVCPercentiles(arg) {
+const calculateTTVCPercentiles = withProfiling(async function calculateTTVCPercentiles(arg) {
   const algo = 'canvas_heatmap';
   if (algo === 'canvas_heatmap') {
     const vcDetails = await calcUsingCanvas(arg);
@@ -16,4 +17,5 @@ export default async function calculateTTVCPercentiles(arg) {
     return vcDetails;
   }
   throw new Error('unexpected Error algo not chosen correctly');
-}
+}, ['vc']);
+export default calculateTTVCPercentiles;

package/dist/es2019/vc/vc-observer-new/metric-calculator/percentile-calc/rect-sweeping-line/calc-union-area.js

@@ -1,3 +1,4 @@
+import { withProfiling } from '../../../../../self-measurements';
 /**
  * Calculate the union areas of all rectangles using Sweep Line Algorithm
  *
@@ -8,7 +9,7 @@
  * @param rectangles
  * @returns
  */
-export default function calculateUnionArea(rectangles) {
+const calculateUnionArea = withProfiling(function calculateUnionArea(rectangles) {
   // Step 1: Create sweep line events
   const events = createSweepLineEvents(rectangles);
 
@@ -27,8 +28,9 @@ export default function calculateUnionArea(rectangles) {
     updateActiveIntervals(activeIntervals, event);
   }
   return totalArea;
-}
-function createSweepLineEvents(rectangles) {
+}, ['vc']);
+export default calculateUnionArea;
+const createSweepLineEvents = withProfiling(function createSweepLineEvents(rectangles) {
   const events = [];
   for (const rect of rectangles) {
     // Create start and end events for each rectangle
@@ -47,8 +49,8 @@ function createSweepLineEvents(rectangles) {
   }
   // Sort events by x-coordinate (and type as tiebreaker)
   return events.sort((a, b) => a.x === b.x ? a.type === 'end' ? 1 : -1 : a.x - b.x);
-}
-function calculateActiveHeight(intervals) {
+}, ['vc']);
+const calculateActiveHeight = withProfiling(function calculateActiveHeight(intervals) {
   if (intervals.size === 0) {
     return 0;
   }
@@ -82,8 +84,8 @@ function calculateActiveHeight(intervals) {
     }
   }
   return totalHeight;
-}
-function updateActiveIntervals(intervals, event) {
+}, ['vc']);
+const updateActiveIntervals = withProfiling(function updateActiveIntervals(intervals, event) {
   const key = `${event.top},${event.bottom}`;
   if (event.type === 'start') {
     intervals.set(key, (intervals.get(key) || 0) + 1);
@@ -95,4 +97,4 @@ function updateActiveIntervals(intervals, event) {
       intervals.delete(key);
     }
   }
-}
+}, ['vc']);

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

@@ -1,7 +1,8 @@
+import { withProfiling } from '../../../../../self-measurements';
 import isViewportEntryData from '../../utils/is-viewport-entry-data';
 import taskYield from '../../utils/task-yield';
 import calculateUnionArea from './calc-union-area';
-export default async function calculateTTVCPercentiles({
+const calculateTTVCPercentiles = withProfiling(async function calculateTTVCPercentiles({
   orderedEntries,
   viewport,
   percentiles,
@@ -56,4 +57,5 @@ export default async function calculateTTVCPercentiles({
     }
   }
   return checkpoints;
-}
+}, ['vc']);
+export default calculateTTVCPercentiles;

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

@@ -1,4 +1,5 @@
-export default function getViewportHeight(document = window.document) {
+import { withProfiling } from '../../../../self-measurements';
+const getViewportHeight = withProfiling(function getViewportHeight(document = window.document) {
   let documentHeight;
   try {
     documentHeight = document.documentElement.clientHeight || 0;
@@ -6,4 +7,5 @@ export default function getViewportHeight(document = window.document) {
     documentHeight = 0;
   }
   return Math.max(documentHeight, window.innerHeight || 0);
-}
+}, ['vc']);
+export default getViewportHeight;

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

@@ -1,4 +1,5 @@
-export default function getViewportWidth(document = window.document) {
+import { withProfiling } from '../../../../self-measurements';
+const getViewportWidth = withProfiling(function getViewportWidth(document = window.document) {
   let documentWidth;
   try {
     documentWidth = document.documentElement.clientWidth || 0;
@@ -6,4 +7,5 @@ export default function getViewportWidth(document = window.document) {
     documentWidth = 0;
   }
   return Math.max(documentWidth, window.innerWidth || 0);
-}
+}, ['vc']);
+export default getViewportWidth;

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

@@ -1,4 +1,5 @@
-export default function isViewportEntryData(data) {
+import { withProfiling } from '../../../../self-measurements';
+const isViewportEntryData = withProfiling(function isViewportEntryData(data) {
   if (data) {
     const hasElementName = typeof data.elementName === 'string';
     const hasRect = typeof data.rect !== 'undefined';
@@ -7,4 +8,5 @@ export default function isViewportEntryData(data) {
     }
   }
   return false;
-}
+}, ['vc']);
+export default isViewportEntryData;

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

@@ -1,5 +1,7 @@
+import { withProfiling } from '../../../../self-measurements';
+
 // See https://developer.mozilla.org/en-US/docs/Web/API/Prioritized_Task_Scheduling_API
-export default async function taskYield() {
+const taskYield = withProfiling(async function taskYield() {
   // This is using globalThis to allow the yield task to be used outside of a browser env
   if ('scheduler' in globalThis &&
   // @ts-ignore
@@ -14,4 +16,5 @@ export default async function taskYield() {
   });
   setTimeout(resolve, 0);
   await p;
-}
+}, ['vc']);
+export default taskYield;