@jsenv/performance-impact 4.1.0 → 4.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/performance-impact",
-  "version": "4.1.0",
+  "version": "4.1.2",
   "description": "Report pull request impacts on performance metrics",
   "license": "MIT",
   "author": {
@@ -11,7 +11,7 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/jsenv/workflow",
-    "directory": "packages/jsenv-performance-impact"
+    "directory": "packages/performance-impact"
   },
   "engines": {
     "node": ">=16.13.0"
@@ -36,8 +36,8 @@
   },
   "dependencies": {
     "@jsenv/dynamic-import-worker": "1.1.0",
-    "@jsenv/filesystem": "4.1.6",
-    "@jsenv/github-pull-request-impact": "1.7.1",
-    "@jsenv/log": "3.3.2"
+    "@jsenv/filesystem": "4.3.2",
+    "@jsenv/github-pull-request-impact": "1.7.2",
+    "@jsenv/log": "3.4.0"
   }
 }

package/src/importMetricFromFiles.js

@@ -1,39 +1,39 @@
-import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-import { createLogger } from "@jsenv/log"
-import { importOneExportFromFile } from "@jsenv/dynamic-import-worker"
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem";
+import { createLogger } from "@jsenv/log";
+import { importOneExportFromFile } from "@jsenv/dynamic-import-worker";
 
-import { measureMultipleTimes } from "./internal/measureMultipleTimes.js"
-import { assertMetrics } from "./internal/assertions.js"
-import { computeMetricsMedian } from "./internal/computeMetricsMedian.js"
-import { formatMetricsLog } from "./internal/formatMetricsLog.js"
+import { measureMultipleTimes } from "./internal/measureMultipleTimes.js";
+import { assertMetrics } from "./internal/assertions.js";
+import { computeMetricsMedian } from "./internal/computeMetricsMedian.js";
+import { formatMetricsLog } from "./internal/formatMetricsLog.js";
 
 export const importMetricFromFiles = async ({
   logLevel,
   directoryUrl,
   metricsDescriptions,
 }) => {
-  const logger = createLogger({ logLevel })
+  const logger = createLogger({ logLevel });
 
-  directoryUrl = assertAndNormalizeDirectoryUrl(directoryUrl)
+  directoryUrl = assertAndNormalizeDirectoryUrl(directoryUrl);
 
-  const allMetrics = {}
+  const allMetrics = {};
   await Object.keys(metricsDescriptions).reduce(
     async (previous, metricName) => {
-      await previous
+      await previous;
 
-      const metricsDescription = metricsDescriptions[metricName]
+      const metricsDescription = metricsDescriptions[metricName];
       const {
         file,
         iterations,
         msToWaitBetweenEachIteration = 100,
-      } = metricsDescription
-      const url = new URL(file, directoryUrl).href
+      } = metricsDescription;
+      const url = new URL(file, directoryUrl).href;
 
       const measure = async () => {
-        const metrics = await importOneExportFromFile(url)
-        assertMetrics(metrics, `in ${file}`)
-        return metrics
-      }
+        const metrics = await importOneExportFromFile(url);
+        assertMetrics(metrics, `in ${file}`);
+        return metrics;
+      };
 
       const metricsWithIterations = await measureMultipleTimes(
         measure,
@@ -41,15 +41,15 @@ export const importMetricFromFiles = async ({
         {
           msToWaitBetweenEachIteration,
         },
-      )
-      const metrics = computeMetricsMedian(metricsWithIterations)
+      );
+      const metrics = computeMetricsMedian(metricsWithIterations);
 
-      logger.info(formatMetricsLog(metrics))
+      logger.info(formatMetricsLog(metrics));
 
-      allMetrics[metricName] = metrics
+      allMetrics[metricName] = metrics;
     },
     Promise.resolve(),
-  )
+  );
 
-  return allMetrics
-}
+  return allMetrics;
+};

package/src/internal/assertions.js

@@ -1,17 +1,17 @@
-import { createDetailedMessage } from "@jsenv/log"
+import { createDetailedMessage } from "@jsenv/log";
 
 export const assertPerformanceReport = (performanceReport) => {
   if (typeof performanceReport !== "object" || performanceReport === null) {
     throw new TypeError(
       `performanceReport must be an object, received ${performanceReport}.`,
-    )
+    );
   }
 
   Object.keys(performanceReport).forEach((groupName) => {
-    const metrics = performanceReport[groupName]
-    assertMetrics(metrics)
-  })
-}
+    const metrics = performanceReport[groupName];
+    assertMetrics(metrics);
+  });
+};
 
 export const assertMetrics = (metrics, metricsTrace) => {
   if (typeof metrics !== "object" || metrics === null) {
@@ -19,29 +19,29 @@ export const assertMetrics = (metrics, metricsTrace) => {
       createDetailedMessage(`metrics must be an object, got ${metrics}`, {
         "metrics trace": metricsTrace,
       }),
-    )
+    );
   }
 
   Object.keys(metrics).forEach((metricName) => {
-    const metric = metrics[metricName]
+    const metric = metrics[metricName];
     if (typeof metric !== "object") {
       throw new TypeError(
         `metric must be an object, got ${metric} for ${metricName}`,
-      )
+      );
     }
 
-    const { value } = metric
+    const { value } = metric;
     if (typeof value !== "number") {
       throw new TypeError(
         `metric value must be a number, got ${value} for ${metricName}`,
-      )
+      );
     }
 
-    const { unit } = metric
+    const { unit } = metric;
     if (unit !== undefined && unit !== "ms" && unit !== "byte") {
       throw new TypeError(
         `metric type must be undefined, "ms", or "byte", got ${unit} for ${metricName}`,
-      )
+      );
     }
-  })
-}
+  });
+};

package/src/internal/comment/createPerfImpactComment.js

@@ -1,4 +1,4 @@
-import { renderGroupImpactTable } from "./renderGroupImpactTable.js"
+import { renderGroupImpactTable } from "./renderGroupImpactTable.js";
 
 export const createPerfImpactComment = ({
   pullRequestBase,
@@ -9,47 +9,47 @@ export const createPerfImpactComment = ({
   formatGroupSummary,
   formatPerformanceImpactCell,
 }) => {
-  const warnings = []
+  const warnings = [];
 
   // here we have are sure beforeMergeData and afterMergeData are valid
   // because we assert their shape is correct in reportPerformanceImpact.js#collectInfo()
   // for metrics here before merge but are no longer in afetr merge, we will ignore them
   // for new metrics we'll show them without doing the diff
 
-  const beforeMergeGroups = beforeMergeData
-  const afterMergeGroups = afterMergeData
+  const beforeMergeGroups = beforeMergeData;
+  const afterMergeGroups = afterMergeData;
 
-  const groupNames = Object.keys(afterMergeGroups)
+  const groupNames = Object.keys(afterMergeGroups);
   const metricCount = groupNames.reduce((previous, groupName) => {
-    const afterMergeMetrics = afterMergeGroups[groupName]
-    return previous + Object.keys(afterMergeMetrics).length
-  }, 0)
+    const afterMergeMetrics = afterMergeGroups[groupName];
+    return previous + Object.keys(afterMergeMetrics).length;
+  }, 0);
 
   if (metricCount === 0) {
     const body = `<h4 id="perf-impact">Performance impact</h4>
 
-<p>No impact to compute when merging <em>${pullRequestHead}</em> into <em>${pullRequestBase}</em>: there is no performance metric.</p>`
+<p>No impact to compute when merging <em>${pullRequestHead}</em> into <em>${pullRequestBase}</em>: there is no performance metric.</p>`;
 
-    return { warnings, body }
+    return { warnings, body };
   }
 
-  const groups = []
+  const groups = [];
   groupNames.forEach((groupName) => {
-    const afterMergeMetrics = afterMergeGroups[groupName]
-    const afterMergeMetricCount = Object.keys(afterMergeMetrics).length
+    const afterMergeMetrics = afterMergeGroups[groupName];
+    const afterMergeMetricCount = Object.keys(afterMergeMetrics).length;
     if (afterMergeMetricCount === 0) {
       // skip empty groups
-      return
+      return;
     }
 
-    const beforeMergeMetrics = beforeMergeGroups[groupName]
+    const beforeMergeMetrics = beforeMergeGroups[groupName];
     const bigImpacts = beforeMergeMetrics
       ? getBigImpacts({
           afterMergeMetrics,
           beforeMergeMetrics,
           isPerformanceImpactBig,
         })
-      : {}
+      : {};
 
     groups.push(
       renderDetails({
@@ -66,38 +66,38 @@ export const createPerfImpactComment = ({
           bigImpacts,
         }),
       }),
-    )
-  })
+    );
+  });
 
   const body = `<h4 id="perf-impact">Performance impact</h4>
 
-<p>Impact on ${metricCount} metrics when merging <em>${pullRequestHead}</em> into <em>${pullRequestBase}</em>. Before drawing conclusion, keep in mind <a href="https://github.com/jsenv/workflow/tree/main/packages/jsenv-performance-impact#performance-variability">performance variability</a>.</p>
+<p>Impact on ${metricCount} metrics when merging <em>${pullRequestHead}</em> into <em>${pullRequestBase}</em>. Before drawing conclusion, keep in mind <a href="https://github.com/jsenv/workflow/tree/main/packages/performance-impact#performance-variability">performance variability</a>.</p>
 
 ${groups.join(`
 
-`)}`
+`)}`;
 
-  return { warnings, body }
-}
+  return { warnings, body };
+};
 
 const getBigImpacts = ({
   afterMergeMetrics,
   beforeMergeMetrics,
   isPerformanceImpactBig,
 }) => {
-  const bigImpacts = {}
+  const bigImpacts = {};
 
   Object.keys(afterMergeMetrics).forEach((metricName) => {
-    const metricBeforeMerge = beforeMergeMetrics[metricName]
+    const metricBeforeMerge = beforeMergeMetrics[metricName];
     if (metricBeforeMerge === undefined) {
-      return
+      return;
     }
 
-    const metricAfterMerge = afterMergeMetrics[metricName]
-    const metricUnit = metricAfterMerge.unit
-    const metricValueAfterMerge = metricAfterMerge.value
-    const metricValueBeforeMerge = metricBeforeMerge.value
-    const metricValueDelta = metricValueAfterMerge - metricValueBeforeMerge
+    const metricAfterMerge = afterMergeMetrics[metricName];
+    const metricUnit = metricAfterMerge.unit;
+    const metricValueAfterMerge = metricAfterMerge.value;
+    const metricValueBeforeMerge = metricBeforeMerge.value;
+    const metricValueDelta = metricValueAfterMerge - metricValueBeforeMerge;
     if (
       !isPerformanceImpactBig({
         metricName,
@@ -107,22 +107,22 @@ const getBigImpacts = ({
         metricValueDelta,
       })
     ) {
-      return
+      return;
     }
 
     bigImpacts[metricName] = {
       metricValueAfterMerge,
       metricValueBeforeMerge,
       metricValueDelta,
-    }
-  })
+    };
+  });
 
-  return bigImpacts
-}
+  return bigImpacts;
+};
 
 const renderDetails = ({ summary, content, opened = false, indent = 0 }) => {
   return `${" ".repeat(indent)}<details${opened ? " open" : ""}>
 ${" ".repeat(indent + 2)}<summary>${summary}</summary>
 ${" ".repeat(indent + 2)}${content}
-${" ".repeat(indent)}</details>`
-}
+${" ".repeat(indent)}</details>`;
+};

package/src/internal/comment/formatImpact.js

@@ -1,35 +1,35 @@
-import { formatMetricValue } from "../formatMetricValue.js"
-import { formatRatioAsPercentage } from "../formatRatio.js"
+import { formatMetricValue } from "../formatMetricValue.js";
+import { formatRatioAsPercentage } from "../formatRatio.js";
 
 export const formatImpact = ({
   metricValueBeforeMerge,
   metricValueAfterMerge,
   metricUnit,
 }) => {
-  const diff = metricValueAfterMerge - metricValueBeforeMerge
+  const diff = metricValueAfterMerge - metricValueBeforeMerge;
 
   if (diff === 0) {
-    return ``
+    return ``;
   }
 
   const diffFormatted = `${diff < 0 ? "-" : "+"}${formatMetricValue({
     value: Math.abs(diff),
     unit: metricUnit,
-  })}`
+  })}`;
 
-  return diffFormatted
-}
+  return diffFormatted;
+};
 
 export const formatImpactAsPercentage = ({
   metricValueBeforeMerge,
   metricValueAfterMerge,
 }) => {
-  const diff = metricValueAfterMerge - metricValueBeforeMerge
+  const diff = metricValueAfterMerge - metricValueBeforeMerge;
   const diffRatio =
     metricValueBeforeMerge === 0
       ? 1
       : metricValueAfterMerge === 0
       ? -1
-      : diff / metricValueBeforeMerge
-  return formatRatioAsPercentage(diffRatio)
-}
+      : diff / metricValueBeforeMerge;
+  return formatRatioAsPercentage(diffRatio);
+};

package/src/internal/comment/jsenvCommentParameters.js

@@ -1,9 +1,9 @@
-import { jsenvIsPerformanceImpactBig } from "./jsenvIsPerformanceImpactBig.js"
-import { jsenvFormatGroupSummary } from "./jsenvFormatGroupSummary.js"
-import { jsenvFormatPerformanceImpactCell } from "./jsenvFormatPerformanceImpactCell.js"
+import { jsenvIsPerformanceImpactBig } from "./jsenvIsPerformanceImpactBig.js";
+import { jsenvFormatGroupSummary } from "./jsenvFormatGroupSummary.js";
+import { jsenvFormatPerformanceImpactCell } from "./jsenvFormatPerformanceImpactCell.js";
 
 export const jsenvCommentParameters = {
   isPerformanceImpactBig: jsenvIsPerformanceImpactBig,
   formatGroupSummary: jsenvFormatGroupSummary,
   formatPerformanceImpactCell: jsenvFormatPerformanceImpactCell,
-}
+};

package/src/internal/comment/jsenvFormatGroupSummary.js

@@ -1,4 +1,4 @@
-import { formatRatioAsPercentage } from "../formatRatio.js"
+import { formatRatioAsPercentage } from "../formatRatio.js";
 
 export const jsenvFormatGroupSummary = ({
   groupName,
@@ -6,38 +6,38 @@ export const jsenvFormatGroupSummary = ({
   afterMergeMetrics,
 }) => {
   if (!beforeMergeMetrics) {
-    return `${groupName} (new)`
+    return `${groupName} (new)`;
   }
 
   const allRatios = getAllImpactRatios({
     beforeMergeMetrics,
     afterMergeMetrics,
-  })
-  const ratiosCount = allRatios.length
+  });
+  const ratiosCount = allRatios.length;
   if (ratiosCount === 0) {
-    return `${groupName} (no impact)`
+    return `${groupName} (no impact)`;
   }
 
-  const ratioSum = allRatios.reduce((previous, ratio) => previous + ratio, 0)
+  const ratioSum = allRatios.reduce((previous, ratio) => previous + ratio, 0);
   if (ratioSum === 0) {
-    return `${groupName} (no impact)`
+    return `${groupName} (no impact)`;
   }
 
-  return `${groupName} (${formatRatioAsPercentage(ratioSum / ratiosCount)})`
-}
+  return `${groupName} (${formatRatioAsPercentage(ratioSum / ratiosCount)})`;
+};
 
 const getAllImpactRatios = ({ afterMergeMetrics, beforeMergeMetrics }) => {
-  let allRatios = []
+  let allRatios = [];
   Object.keys(afterMergeMetrics).forEach((metricName) => {
-    const metricBeforeMerge = beforeMergeMetrics[metricName]
+    const metricBeforeMerge = beforeMergeMetrics[metricName];
     if (!metricBeforeMerge) {
       // it's new, let's ignore
-      return
+      return;
     }
-    const metricAfterMerge = afterMergeMetrics[metricName]
-    const metricValueBeforeMerge = metricBeforeMerge.value
-    const metricValueAfterMerge = metricAfterMerge.value
-    const metricDiff = metricValueAfterMerge - metricValueBeforeMerge
+    const metricAfterMerge = afterMergeMetrics[metricName];
+    const metricValueBeforeMerge = metricBeforeMerge.value;
+    const metricValueAfterMerge = metricAfterMerge.value;
+    const metricDiff = metricValueAfterMerge - metricValueBeforeMerge;
     if (
       metricDiff === 0 &&
       metricValueAfterMerge === 0 &&
@@ -45,7 +45,7 @@ const getAllImpactRatios = ({ afterMergeMetrics, beforeMergeMetrics }) => {
     ) {
       // there is no impact on a metric that is 0
       // we can ignore this metric
-      return
+      return;
     }
 
     const metricDiffRatio =
@@ -55,8 +55,8 @@ const getAllImpactRatios = ({ afterMergeMetrics, beforeMergeMetrics }) => {
         ? 1
         : metricValueAfterMerge === 0
         ? -1
-        : metricDiff / metricValueBeforeMerge
-    allRatios.push(metricDiffRatio)
-  })
-  return allRatios
-}
+        : metricDiff / metricValueBeforeMerge;
+    allRatios.push(metricDiffRatio);
+  });
+  return allRatios;
+};

package/src/internal/comment/jsenvFormatPerformanceImpactCell.js

@@ -1,4 +1,4 @@
-import { formatImpact, formatImpactAsPercentage } from "./formatImpact.js"
+import { formatImpact, formatImpactAsPercentage } from "./formatImpact.js";
 
 export const jsenvFormatPerformanceImpactCell = ({
   metricUnit,
@@ -7,23 +7,23 @@ export const jsenvFormatPerformanceImpactCell = ({
 }) => {
   // metric is new
   if (metricValueBeforeMerge === undefined) {
-    return ``
+    return ``;
   }
 
-  const diff = metricValueAfterMerge - metricValueBeforeMerge
+  const diff = metricValueAfterMerge - metricValueBeforeMerge;
   if (diff === 0) {
-    return ``
+    return ``;
   }
 
   const diffFormatted = formatImpact({
     metricUnit,
     metricValueAfterMerge,
     metricValueBeforeMerge,
-  })
+  });
   const diffAsPercentageFormatted = formatImpactAsPercentage({
     metricUnit,
     metricValueBeforeMerge,
     metricValueAfterMerge,
-  })
-  return `${diffFormatted} / ${diffAsPercentageFormatted}`
-}
+  });
+  return `${diffFormatted} / ${diffAsPercentageFormatted}`;
+};

package/src/internal/comment/jsenvIsPerformanceImpactBig.js

@@ -2,14 +2,14 @@ export const jsenvIsPerformanceImpactBig = ({
   metricValueBeforeMerge,
   metricValueDelta,
 }) => {
-  const absoluteDelta = Math.abs(metricValueDelta)
+  const absoluteDelta = Math.abs(metricValueDelta);
   const absoluteDeltaAsRatio =
-    absoluteDelta === 0 ? 0 : absoluteDelta / metricValueBeforeMerge
-  const absoluteDeltaAsPercentage = absoluteDeltaAsRatio * 100
+    absoluteDelta === 0 ? 0 : absoluteDelta / metricValueBeforeMerge;
+  const absoluteDeltaAsPercentage = absoluteDeltaAsRatio * 100;
 
   // absolute diff as percentage is below 5% -> not big
   if (absoluteDeltaAsPercentage < 5) {
-    return false
+    return false;
   }
-  return true
-}
+  return true;
+};

package/src/internal/comment/renderGroupImpactTable.js

@@ -1,7 +1,7 @@
-import { formatMetricValue } from "../formatMetricValue.js"
+import { formatMetricValue } from "../formatMetricValue.js";
 
-const METRIC_NAME_MAX_LENGTH = 50
-const MAX_METRIC_PER_GROUP = 20
+const METRIC_NAME_MAX_LENGTH = 50;
+const MAX_METRIC_PER_GROUP = 20;
 
 export const renderGroupImpactTable = ({
   formatPerformanceImpactCell,
@@ -26,8 +26,8 @@ export const renderGroupImpactTable = ({
         bigImpacts,
       })}
     </tbody>
-  </table>`
-}
+  </table>`;
+};
 
 const renderPerfImpactTableBody = ({
   formatPerformanceImpactCell,
@@ -35,21 +35,21 @@ const renderPerfImpactTableBody = ({
   afterMergeMetrics,
   bigImpacts,
 }) => {
-  const lines = []
-  const metricAllNames = Object.keys(afterMergeMetrics)
-  const metricCount = metricAllNames.length
+  const lines = [];
+  const metricAllNames = Object.keys(afterMergeMetrics);
+  const metricCount = metricAllNames.length;
   const metricNames =
     metricCount > MAX_METRIC_PER_GROUP
       ? metricAllNames.slice(0, MAX_METRIC_PER_GROUP)
-      : metricAllNames
+      : metricAllNames;
 
   metricNames.forEach((metricName) => {
-    const metricNameDisplayed = truncateMetricName(metricName)
-    const metric = afterMergeMetrics[metricName]
-    const metricValueAfterMerge = metric.value
+    const metricNameDisplayed = truncateMetricName(metricName);
+    const metric = afterMergeMetrics[metricName];
+    const metricValueAfterMerge = metric.value;
     const metricBeforeMerge = beforeMergeMetrics
       ? beforeMergeMetrics[metricName]
-      : undefined
+      : undefined;
     if (!metricBeforeMerge) {
       lines.push([
         `<td nowrap>${metricNameDisplayed}</td>`,
@@ -62,12 +62,12 @@ const renderPerfImpactTableBody = ({
           isBig: false,
         })}</td>`,
         `<td>:baby:</td>`,
-      ])
-      return
+      ]);
+      return;
     }
 
-    const isBig = Boolean(bigImpacts[metricName])
-    const metricValueBeforeMerge = metricBeforeMerge.value
+    const isBig = Boolean(bigImpacts[metricName]);
+    const metricValueBeforeMerge = metricBeforeMerge.value;
     lines.push([
       `<td nowrap>${metricNameDisplayed}</td>`,
       `<td nowrap>${formatMetricValue(metricBeforeMerge)}</td>`,
@@ -82,50 +82,50 @@ const renderPerfImpactTableBody = ({
         metricValueAfterMerge,
         metricValueBeforeMerge,
       })}</td>`,
-    ])
-  })
+    ]);
+  });
   if (metricNames !== metricAllNames) {
     lines.push([
       `<td colspan="5" align="center">... ${
         metricCount - MAX_METRIC_PER_GROUP
       } more ...</td>`,
-    ])
+    ]);
   }
 
-  return renderTableLines(lines)
-}
+  return renderTableLines(lines);
+};
 
 const renderEmojiCellContent = ({
   metricValueAfterMerge,
   metricValueBeforeMerge,
 }) => {
-  const delta = metricValueAfterMerge - metricValueBeforeMerge
+  const delta = metricValueAfterMerge - metricValueBeforeMerge;
   if (delta === 0) {
-    return ":ghost:"
+    return ":ghost:";
   }
 
   if (delta > 0) {
-    return ":arrow_upper_right:"
+    return ":arrow_upper_right:";
   }
 
-  return ":arrow_lower_right:"
-}
+  return ":arrow_lower_right:";
+};
 
 const truncateMetricName = (metricName) => {
-  const length = metricName.length
+  const length = metricName.length;
   if (length > METRIC_NAME_MAX_LENGTH) {
-    return `${metricName.slice(0, METRIC_NAME_MAX_LENGTH - `…`.length)}…`
+    return `${metricName.slice(0, METRIC_NAME_MAX_LENGTH - `…`.length)}…`;
   }
-  return metricName
-}
+  return metricName;
+};
 
 const renderTableLines = (lines, { indentCount = 3, indentSize = 2 } = {}) => {
   if (lines.length === 0) {
-    return ""
+    return "";
   }
 
-  const cellLeftSpacing = indent(indentCount + 1, indentSize)
-  const lineLeftSpacing = indent(indentCount, indentSize)
+  const cellLeftSpacing = indent(indentCount + 1, indentSize);
+  const lineLeftSpacing = indent(indentCount, indentSize);
 
   return `<tr>${lines.map(
     (cells) => `
@@ -134,7 +134,7 @@ ${cellLeftSpacing}`)}`,
   ).join(`
 ${lineLeftSpacing}</tr>
 ${lineLeftSpacing}<tr>`)}
-${lineLeftSpacing}</tr>`
-}
+${lineLeftSpacing}</tr>`;
+};
 
-const indent = (count, size) => ` `.repeat(size * count)
+const indent = (count, size) => ` `.repeat(size * count);

package/src/internal/computeMetricsMedian.js

@@ -1,15 +1,15 @@
-import { median } from "./median.js"
+import { median } from "./median.js";
 
 export const computeMetricsMedian = (metrics) => {
-  const metricsMedian = {}
+  const metricsMedian = {};
 
   Object.keys(metrics).forEach((metricName) => {
-    const metricWithIteration = metrics[metricName]
+    const metricWithIteration = metrics[metricName];
     metricsMedian[metricName] = {
       value: median(metricWithIteration.values),
       unit: metricWithIteration.unit,
-    }
-  })
+    };
+  });
 
-  return metricsMedian
-}
+  return metricsMedian;
+};

package/src/internal/formatMetricValue.js

@@ -1,11 +1,11 @@
-import { byteAsFileSize, msAsDuration } from "@jsenv/log"
+import { byteAsFileSize, msAsDuration } from "@jsenv/log";
 
 export const formatMetricValue = ({ value, unit }) => {
-  return formatters[unit](value)
-}
+  return formatters[unit](value);
+};
 
 const formatters = {
   ms: msAsDuration,
   byte: byteAsFileSize,
   undefined: (value) => value,
-}
+};

package/src/internal/formatMetricsLog.js

@@ -1,9 +1,9 @@
-import { formatMetricValue } from "./formatMetricValue.js"
+import { formatMetricValue } from "./formatMetricValue.js";
 
 export const formatMetricsLog = (metrics) => {
-  const metricsReadable = {}
+  const metricsReadable = {};
   Object.keys(metrics).forEach((metricName) => {
-    metricsReadable[metricName] = formatMetricValue(metrics[metricName])
-  })
-  return JSON.stringify(metricsReadable, null, "  ")
-}
+    metricsReadable[metricName] = formatMetricValue(metrics[metricName]);
+  });
+  return JSON.stringify(metricsReadable, null, "  ");
+};

package/src/internal/formatRatio.js

@@ -1,12 +1,12 @@
-import { setRoundedPrecision } from "@jsenv/log"
+import { setRoundedPrecision } from "@jsenv/log";
 
 export const formatRatioAsPercentage = (ratio) => {
-  const percentage = ratio * 100
+  const percentage = ratio * 100;
   return `${percentage < 0 ? `-` : "+"}${setRoundedPrecision(
     Math.abs(percentage),
     {
       decimals: 0,
       decimalsWhenSmall: 1,
     },
-  )}%`
-}
+  )}%`;
+};

package/src/internal/measureMultipleTimes.js

@@ -1,6 +1,6 @@
-import { createDetailedMessage } from "@jsenv/log"
+import { createDetailedMessage } from "@jsenv/log";
 
-import { assertMetrics } from "./assertions.js"
+import { assertMetrics } from "./assertions.js";
 
 export const measureMultipleTimes = async (
   measure,
@@ -8,53 +8,53 @@ export const measureMultipleTimes = async (
   { msToWaitBetweenEachIteration = 0 } = {},
 ) => {
   if (typeof measure !== "function") {
-    throw new TypeError(`measure must be a function, received ${measure}`)
+    throw new TypeError(`measure must be a function, received ${measure}`);
   }
   if (typeof iterationCount !== "number") {
     throw new TypeError(
       `iterationCount must be a number, received ${iterationCount}`,
-    )
+    );
   }
 
-  const firstIterationMetrics = await measure()
-  assertMetrics(firstIterationMetrics)
-  const firstIterationMetricNames = Object.keys(firstIterationMetrics)
+  const firstIterationMetrics = await measure();
+  assertMetrics(firstIterationMetrics);
+  const firstIterationMetricNames = Object.keys(firstIterationMetrics);
   if (firstIterationMetricNames.length === 0) {
     throw new Error(
       `measure must return a non empty object, received an object without key`,
-    )
+    );
   }
 
-  const metricsWithIteration = {}
+  const metricsWithIteration = {};
   firstIterationMetricNames.forEach((metricName) => {
-    const metric = firstIterationMetrics[metricName]
+    const metric = firstIterationMetrics[metricName];
     metricsWithIteration[metricName] = {
       values: [metric.value],
       unit: metric.unit,
-    }
-  })
+    };
+  });
 
   if (iterationCount === 1) {
-    return metricsWithIteration
+    return metricsWithIteration;
   }
 
-  const iterationArray = new Array(iterationCount - 1).fill()
+  const iterationArray = new Array(iterationCount - 1).fill();
   await iterationArray.reduce(async (previous, _, index) => {
-    await previous
+    await previous;
 
-    const currentMetrics = await measure()
-    assertMetrics(currentMetrics)
-    const currentIterationMetricNames = Object.keys(currentMetrics)
+    const currentMetrics = await measure();
+    assertMetrics(currentMetrics);
+    const currentIterationMetricNames = Object.keys(currentMetrics);
     const missingMetricNamesInCurrentIteration =
       firstIterationMetricNames.filter(
         (firstIterationMetricName) =>
           !currentIterationMetricNames.includes(firstIterationMetricName),
-      )
+      );
     const extraMetricNamesInCurrentIteration =
       currentIterationMetricNames.filter(
         (currentIterationMetricName) =>
           !firstIterationMetricNames.includes(currentIterationMetricName),
-      )
+      );
     if (
       missingMetricNamesInCurrentIteration.length ||
       extraMetricNamesInCurrentIteration.length
@@ -65,12 +65,12 @@ export const measureMultipleTimes = async (
           extraMetricNamesInCurrentIteration,
           iterationIndex: index,
         }),
-      )
+      );
     }
 
     firstIterationMetricNames.forEach((metricName) => {
-      const metricWithIteration = metricsWithIteration[metricName]
-      const currentMetric = currentMetrics[metricName]
+      const metricWithIteration = metricsWithIteration[metricName];
+      const currentMetric = currentMetrics[metricName];
       if (currentMetric.unit !== metricWithIteration.unit) {
         throw new Error(
           createDetailedMessage(
@@ -81,19 +81,19 @@ export const measureMultipleTimes = async (
               "metric name": metricName,
             },
           ),
-        )
+        );
       }
-      metricWithIteration.values.push(currentMetric.value)
-    })
+      metricWithIteration.values.push(currentMetric.value);
+    });
 
     // await a little bit to let previous execution the time to potentially clean up things
     await new Promise((resolve) => {
-      setTimeout(resolve, msToWaitBetweenEachIteration)
-    })
-  }, Promise.resolve())
+      setTimeout(resolve, msToWaitBetweenEachIteration);
+    });
+  }, Promise.resolve());
 
-  return metricsWithIteration
-}
+  return metricsWithIteration;
+};
 
 const createVariableMetricNamesErrorMessage = ({
   missingMetricNamesInCurrentIteration,
@@ -116,5 +116,5 @@ const createVariableMetricNamesErrorMessage = ({
           }
         : {}),
     },
-  )
-}
+  );
+};

package/src/internal/median.js

@@ -8,21 +8,21 @@
  */
 
 export const median = (numbers) => {
-  const numberCount = numbers.length
-  const numbersSorted = numbers.slice()
-  numbersSorted.sort()
+  const numberCount = numbers.length;
+  const numbersSorted = numbers.slice();
+  numbersSorted.sort();
 
-  const isEven = numberCount % 2 === 0
+  const isEven = numberCount % 2 === 0;
   if (isEven) {
-    const rightMiddleNumberIndex = numberCount / 2
-    const leftMiddleNumberIndex = rightMiddleNumberIndex - 1
-    const leftMiddleNumber = numbersSorted[leftMiddleNumberIndex]
-    const rightMiddleNumber = numbersSorted[rightMiddleNumberIndex]
-    const medianNumber = (leftMiddleNumber + rightMiddleNumber) / 2
-    return medianNumber
+    const rightMiddleNumberIndex = numberCount / 2;
+    const leftMiddleNumberIndex = rightMiddleNumberIndex - 1;
+    const leftMiddleNumber = numbersSorted[leftMiddleNumberIndex];
+    const rightMiddleNumber = numbersSorted[rightMiddleNumberIndex];
+    const medianNumber = (leftMiddleNumber + rightMiddleNumber) / 2;
+    return medianNumber;
   }
 
-  const medianNumberIndex = (numberCount - 1) / 2
-  const medianNumber = numbersSorted[medianNumberIndex]
-  return medianNumber
-}
+  const medianNumberIndex = (numberCount - 1) / 2;
+  const medianNumber = numbersSorted[medianNumberIndex];
+  return medianNumber;
+};

package/src/main.js

@@ -1,5 +1,5 @@
-export { readGitHubWorkflowEnv } from "@jsenv/github-pull-request-impact"
+export { readGitHubWorkflowEnv } from "@jsenv/github-pull-request-impact";
 
-export { startMeasures } from "./startMeasures.js"
-export { importMetricFromFiles } from "./importMetricFromFiles.js"
-export { reportPerformanceImpact } from "./reportPerformanceImpact.js"
+export { startMeasures } from "./startMeasures.js";
+export { importMetricFromFiles } from "./importMetricFromFiles.js";
+export { reportPerformanceImpact } from "./reportPerformanceImpact.js";

package/src/reportPerformanceImpact.js

@@ -1,10 +1,10 @@
-import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-import { commentGitHubPullRequestImpact } from "@jsenv/github-pull-request-impact"
-import { importOneExportFromFile } from "@jsenv/dynamic-import-worker"
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem";
+import { commentGitHubPullRequestImpact } from "@jsenv/github-pull-request-impact";
+import { importOneExportFromFile } from "@jsenv/dynamic-import-worker";
 
-import { assertPerformanceReport } from "./internal/assertions.js"
-import { createPerfImpactComment } from "./internal/comment/createPerfImpactComment.js"
-import { jsenvCommentParameters } from "./internal/comment/jsenvCommentParameters.js"
+import { assertPerformanceReport } from "./internal/assertions.js";
+import { createPerfImpactComment } from "./internal/comment/createPerfImpactComment.js";
+import { jsenvCommentParameters } from "./internal/comment/jsenvCommentParameters.js";
 
 export const reportPerformanceImpact = async ({
   logLevel,
@@ -26,14 +26,14 @@ export const reportPerformanceImpact = async ({
   runLink,
   commitInGeneratedByInfo,
 }) => {
-  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
+  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl);
   if (performanceReportUrl === "string") {
-    performanceReportUrl = new URL(performanceReportUrl, rootDirectoryUrl).href
+    performanceReportUrl = new URL(performanceReportUrl, rootDirectoryUrl).href;
   } else if (performanceReportUrl instanceof URL) {
   } else {
     throw new TypeError(
       `performanceReportUrl must be a string or an url but received ${performanceReportUrl}`,
-    )
+    );
   }
 
   return commentGitHubPullRequestImpact({
@@ -48,12 +48,12 @@ export const reportPerformanceImpact = async ({
     pullRequestNumber,
 
     collectInfo: async ({ execCommandInRootDirectory }) => {
-      await execCommandInRootDirectory(installCommand)
+      await execCommandInRootDirectory(installCommand);
       const performanceReport = await importOneExportFromFile(
         performanceReportUrl,
-      )
-      assertPerformanceReport(performanceReport)
-      return { version: 1, data: performanceReport }
+      );
+      assertPerformanceReport(performanceReport);
+      return { version: 1, data: performanceReport };
     },
     commentIdentifier: `<!-- Generated by @jsenv/performance-impact -->`,
     createCommentForComparison: ({
@@ -70,13 +70,13 @@ export const reportPerformanceImpact = async ({
         isPerformanceImpactBig,
         formatGroupSummary,
         formatPerformanceImpactCell,
-      })
+      });
     },
     generatedByLink: {
-      url: "https://github.com/jsenv/workflow/tree/main/packages/jsenv-performance-impact",
+      url: "https://github.com/jsenv/workflow/tree/main/packages/performance-impact",
       text: "@jsenv/performance-impact",
     },
     runLink,
     commitInGeneratedByInfo,
-  })
-}
+  });
+};

package/src/startMeasures.js

@@ -1,6 +1,6 @@
-import { resourceUsage, memoryUsage, emitWarning } from "node:process"
-import v8 from "node:v8"
-import { runInNewContext } from "node:vm"
+import { resourceUsage, memoryUsage, emitWarning } from "node:process";
+import v8 from "node:v8";
+import { runInNewContext } from "node:vm";
 
 export const startMeasures = ({
   duration = true, // will be in milliseconds
@@ -9,48 +9,49 @@ export const startMeasures = ({
   gc = false,
 } = {}) => {
   if (gc && !global.gc) {
-    v8.setFlagsFromString("--expose_gc")
-    global.gc = runInNewContext("gc")
+    v8.setFlagsFromString("--expose_gc");
+    global.gc = runInNewContext("gc");
     emitWarning(`node must be started with --expose-gc`, {
       CODE: "EXPOSE_GC_IS_MISSING",
       detail: "global.gc forced with v8.setFlagsFromString",
-    })
+    });
   }
 
-  const measures = []
+  const measures = [];
   if (duration) {
-    const beforeMs = Date.now()
+    const beforeMs = Date.now();
     measures.push(() => {
-      const afterMs = Date.now()
-      const duration = afterMs - beforeMs
+      const afterMs = Date.now();
+      const duration = afterMs - beforeMs;
       return {
         duration,
-      }
-    })
+      };
+    });
   }
   if (filesystem) {
-    const beforeRessourceUsage = resourceUsage()
+    const beforeRessourceUsage = resourceUsage();
     measures.push(() => {
-      const afterRessourceUsage = resourceUsage()
-      const fsRead = afterRessourceUsage.fsRead - beforeRessourceUsage.fsRead
-      const fsWrite = afterRessourceUsage.fsWrite - beforeRessourceUsage.fsWrite
+      const afterRessourceUsage = resourceUsage();
+      const fsRead = afterRessourceUsage.fsRead - beforeRessourceUsage.fsRead;
+      const fsWrite =
+        afterRessourceUsage.fsWrite - beforeRessourceUsage.fsWrite;
       return {
         fsRead,
         fsWrite,
-      }
-    })
+      };
+    });
   }
 
   if (memoryHeap) {
     if (gc) {
-      global.gc()
+      global.gc();
     }
-    const beforeMemoryUsage = memoryUsage()
+    const beforeMemoryUsage = memoryUsage();
     measures.push(() => {
       if (gc) {
-        global.gc()
+        global.gc();
       }
-      const afterMemoryUsage = memoryUsage()
+      const afterMemoryUsage = memoryUsage();
       return {
         // total means "allocated"
         memoryHeapTotal:
@@ -60,20 +61,20 @@ export const startMeasures = ({
         rss: afterMemoryUsage.rss - beforeMemoryUsage.rss,
         arrayBuffers:
           afterMemoryUsage.arrayBuffers - beforeMemoryUsage.arrayBuffers,
-      }
-    })
+      };
+    });
   }
 
   const stop = () => {
-    let metrics = {}
+    let metrics = {};
     measures.forEach((measure) => {
       metrics = {
         ...metrics,
         ...measure(),
-      }
-    })
-    return metrics
-  }
+      };
+    });
+    return metrics;
+  };
 
-  return { stop }
-}
+  return { stop };
+};