@jsenv/lighthouse-impact 4.0.4 → 4.0.5

package/README.md

@@ -33,26 +33,26 @@ _lighthouse.mjs_
  * - It starts a local server serving a single basic HTML file
  * - It is meant to be modified to use your own server and website files
  */
-import { chromium } from "playwright"
-import { createServer } from "node:http"
-import { readFileSync } from "node:fs"
-import { runLighthouseOnPlaywrightPage } from "@jsenv/lighthouse-impact"
+import { chromium } from "playwright";
+import { createServer } from "node:http";
+import { readFileSync } from "node:fs";
+import { runLighthouseOnPlaywrightPage } from "@jsenv/lighthouse-impact";
 
-const htmlFileUrl = new URL("./index.html", import.meta.url)
-const html = String(readFileSync(htmlFileUrl))
+const htmlFileUrl = new URL("./index.html", import.meta.url);
+const html = String(readFileSync(htmlFileUrl));
 
 const server = createServer((request, response) => {
   response.writeHead(200, {
     "content-type": "text/html",
-  })
-  response.end(html)
-})
-server.listen(8080)
-server.unref()
+  });
+  response.end(html);
+});
+server.listen(8080);
+server.unref();
 
 const browser = await chromium.launch({
   args: ["--remote-debugging-port=9222"],
-})
+});
 const browserContext = await browser.newContext({
   // userAgent: "",
   ignoreHTTPSErrors: true,
@@ -67,13 +67,13 @@ const browserContext = await browser.newContext({
   hasTouch: true,
   isMobile: true,
   deviceScaleFactor: 1,
-})
-const page = await browserContext.newPage()
-await page.goto(server.origin)
+});
+const page = await browserContext.newPage();
+await page.goto(server.origin);
 
 export const lighthouseReport = await runLighthouseOnPlaywrightPage(page, {
   chromiumPort: 9222,
-})
+});
 ```
 
 _index.html_
@@ -144,7 +144,7 @@ _report_lighthouse_impact.mjs_
 import {
   reportLighthouseImpactInGithubPullRequest,
   readGitHubWorkflowEnv,
-} from "@jsenv/lighthouse-impact"
+} from "@jsenv/lighthouse-impact";
 
 await reportLighthouseImpactInGithubPullRequest({
   ...readGitHubWorkflowEnv(),
@@ -152,7 +152,7 @@ await reportLighthouseImpactInGithubPullRequest({
     "./lighthouse.mjs#lighthouseReport",
     import.meta.url,
   ),
-})
+});
 ```
 
 ## Other tools

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/lighthouse-impact",
-  "version": "4.0.4",
+  "version": "4.0.5",
   "description": "Package description",
   "license": "MIT",
   "author": {
@@ -37,9 +37,9 @@
   "dependencies": {
     "@jsenv/abort": "4.2.4",
     "@jsenv/dynamic-import-worker": "1.1.0",
-    "@jsenv/filesystem": "4.2.3",
+    "@jsenv/filesystem": "4.3.2",
     "@jsenv/github-pull-request-impact": "1.7.2",
-    "@jsenv/log": "3.3.4",
+    "@jsenv/log": "3.4.0",
     "lighthouse": "10.2.0"
   }
 }

package/src/generate/generate_lighthouse_report.js

@@ -1,8 +1,8 @@
 // https://github.com/GoogleChrome/lighthouse/blob/5a14deb5c4e0ec4e8e58f50ff72b53851b021bcf/docs/readme.md#using-programmatically
 
-import { assertAndNormalizeFileUrl, writeFileSync } from "@jsenv/filesystem"
-import { createLogger } from "@jsenv/log"
-import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
+import { assertAndNormalizeFileUrl, writeFileSync } from "@jsenv/filesystem";
+import { createLogger } from "@jsenv/log";
+import { Abort, raceProcessTeardownEvents } from "@jsenv/abort";
 
 import {
   runLighthouse,
@@ -10,7 +10,7 @@ import {
   formatReportAsSummaryText,
   formatReportAsJson,
   formatReportAsHtml,
-} from "./lighthouse_api.js"
+} from "./lighthouse_api.js";
 
 export const generateLighthouseReport = async (
   url,
@@ -49,11 +49,11 @@ export const generateLighthouseReport = async (
   if (chromiumDebuggingPort === undefined) {
     throw new Error(
       `"chromiumDebuggingPort" is required, got ${chromiumDebuggingPort}`,
-    )
+    );
   }
 
-  const generateReportOperation = Abort.startOperation()
-  generateReportOperation.addAbortSignal(signal)
+  const generateReportOperation = Abort.startOperation();
+  generateReportOperation.addAbortSignal(signal);
   if (handleSIGINT) {
     generateReportOperation.addAbortSource((abort) => {
       return raceProcessTeardownEvents(
@@ -61,14 +61,14 @@ export const generateLighthouseReport = async (
           SIGINT: true,
         },
         abort,
-      )
-    })
+      );
+    });
   }
 
   const jsenvGenerateLighthouseReport = async () => {
-    const logger = createLogger({ logLevel })
+    const logger = createLogger({ logLevel });
     if (generateReportOperation.signal.aborted) {
-      return { aborted: true }
+      return { aborted: true };
     }
     const lighthouseOptions = {
       extends: "lighthouse:default",
@@ -86,56 +86,56 @@ export const generateLighthouseReport = async (
         emulatedUserAgent,
         ...lighthouseSettings,
       },
-    }
-    const reports = []
+    };
+    const reports = [];
     try {
       await Array(runCount)
         .fill()
         .reduce(async (previous, _, index) => {
-          generateReportOperation.throwIfAborted()
-          await previous
+          generateReportOperation.throwIfAborted();
+          await previous;
           if (index > 0 && delayBetweenEachRun) {
             await new Promise((resolve) =>
               setTimeout(resolve, delayBetweenEachRun),
-            )
+            );
           }
-          generateReportOperation.throwIfAborted()
-          const report = await runLighthouse(url, lighthouseOptions)
-          reports.push(report)
-        }, Promise.resolve())
+          generateReportOperation.throwIfAborted();
+          const report = await runLighthouse(url, lighthouseOptions);
+          reports.push(report);
+        }, Promise.resolve());
     } catch (e) {
       if (Abort.isAbortError(e)) {
-        return { aborted: true }
+        return { aborted: true };
       }
-      throw e
+      throw e;
     }
 
-    const lighthouseReport = await reduceToMedianReport(reports)
+    const lighthouseReport = await reduceToMedianReport(reports);
     if (log) {
-      logger.info(formatReportAsSummaryText(lighthouseReport))
+      logger.info(formatReportAsSummaryText(lighthouseReport));
     }
     if (jsonFileUrl) {
-      assertAndNormalizeFileUrl(jsonFileUrl)
-      const json = formatReportAsJson(lighthouseReport)
-      writeFileSync(jsonFileUrl, json)
+      assertAndNormalizeFileUrl(jsonFileUrl);
+      const json = formatReportAsJson(lighthouseReport);
+      writeFileSync(jsonFileUrl, json);
       if (jsonFileLog) {
-        logger.info(`-> ${jsonFileUrl}`)
+        logger.info(`-> ${jsonFileUrl}`);
       }
     }
     if (htmlFileUrl) {
-      assertAndNormalizeFileUrl(htmlFileUrl)
-      const html = await formatReportAsHtml(lighthouseReport)
-      writeFileSync(htmlFileUrl, html)
+      assertAndNormalizeFileUrl(htmlFileUrl);
+      const html = await formatReportAsHtml(lighthouseReport);
+      writeFileSync(htmlFileUrl, html);
       if (htmlFileLog) {
-        logger.info(`-> ${htmlFileUrl}`)
+        logger.info(`-> ${htmlFileUrl}`);
       }
     }
-    return lighthouseReport
-  }
+    return lighthouseReport;
+  };
 
   try {
-    return await jsenvGenerateLighthouseReport()
+    return await jsenvGenerateLighthouseReport();
   } finally {
-    await generateReportOperation.end()
+    await generateReportOperation.end();
   }
-}
+};

package/src/generate/lighthouse_api.js

@@ -1,42 +1,44 @@
 export const runLighthouse = async (url, lighthouseOptions) => {
-  const { default: lighthouse } = await import("lighthouse")
-  const results = await lighthouse(url, undefined, lighthouseOptions)
+  const { default: lighthouse } = await import("lighthouse");
+  const results = await lighthouse(url, undefined, lighthouseOptions);
   // use results.lhr for the JS-consumeable output
   // https://github.com/GoogleChrome/lighthouse/blob/master/types/lhr.d.ts
   // use results.report for the HTML/JSON/CSV output as a string
   // use results.artifacts for the trace/screenshots/other specific case you need (rarer)
-  const { lhr } = results
-  const { runtimeError } = lhr
+  const { lhr } = results;
+  const { runtimeError } = lhr;
   if (runtimeError) {
-    const error = new Error(runtimeError.message)
-    Object.assign(error, runtimeError)
-    throw error
+    const error = new Error(runtimeError.message);
+    Object.assign(error, runtimeError);
+    throw error;
   }
-  return lhr
-}
+  return lhr;
+};
 
 export const reduceToMedianReport = async (lighthouseReports) => {
-  const { computeMedianRun } = await import("lighthouse/core/lib/median-run.js")
-  return computeMedianRun(lighthouseReports)
-}
+  const { computeMedianRun } = await import(
+    "lighthouse/core/lib/median-run.js"
+  );
+  return computeMedianRun(lighthouseReports);
+};
 
 export const formatReportAsSummaryText = (lighthouseReport) => {
-  const scores = {}
+  const scores = {};
   Object.keys(lighthouseReport.categories).forEach((name) => {
-    scores[name] = lighthouseReport.categories[name].score
-  })
-  return JSON.stringify(scores, null, "  ")
-}
+    scores[name] = lighthouseReport.categories[name].score;
+  });
+  return JSON.stringify(scores, null, "  ");
+};
 
 export const formatReportAsJson = (lighthouseReport) => {
-  const json = JSON.stringify(lighthouseReport, null, "  ")
-  return json
-}
+  const json = JSON.stringify(lighthouseReport, null, "  ");
+  return json;
+};
 
 export const formatReportAsHtml = async (lighthouseReport) => {
   const { ReportGenerator } = await import(
     "lighthouse/report/generator/report-generator.js"
-  )
-  const html = ReportGenerator.generateReportHtml(lighthouseReport)
-  return html
-}
+  );
+  const html = ReportGenerator.generateReportHtml(lighthouseReport);
+  return html;
+};

package/src/main.js

@@ -1,4 +1,4 @@
-export { readGitHubWorkflowEnv } from "@jsenv/github-pull-request-impact"
+export { readGitHubWorkflowEnv } from "@jsenv/github-pull-request-impact";
 
-export { runLighthouseOnPlaywrightPage } from "./run_lighthouse_on_playwright_page.js"
-export { reportLighthouseImpactInGithubPullRequest } from "./report_lighthouse_impact_in_github_pr.js"
+export { runLighthouseOnPlaywrightPage } from "./run_lighthouse_on_playwright_page.js";
+export { reportLighthouseImpactInGithubPullRequest } from "./report_lighthouse_impact_in_github_pr.js";

package/src/pr_impact/createLighthouseImpactComment.js

@@ -1,4 +1,4 @@
-import { formatNumericDiff } from "./formatNumericDiff.js"
+import { formatNumericDiff } from "./formatNumericDiff.js";
 
 export const createLighthouseImpactComment = ({
   pullRequestBase,
@@ -8,33 +8,33 @@ export const createLighthouseImpactComment = ({
   beforeMergeGist,
   afterMergeGist,
 }) => {
-  const warnings = []
+  const warnings = [];
 
-  const beforeMergeVersion = beforeMergeLighthouseReport.lighthouseVersion
-  const afterMergeVersion = afterMergeLighthouseReport.lighthouseVersion
-  let impactAnalysisEnabled = true
+  const beforeMergeVersion = beforeMergeLighthouseReport.lighthouseVersion;
+  const afterMergeVersion = afterMergeLighthouseReport.lighthouseVersion;
+  let impactAnalysisEnabled = true;
   if (beforeMergeVersion !== afterMergeVersion) {
-    impactAnalysisEnabled = false
+    impactAnalysisEnabled = false;
     warnings.push(
       `**Warning:** Impact analysis skipped because lighthouse version are different on \`${pullRequestBase}\` (${beforeMergeVersion}) and \`${pullRequestHead}\` (${afterMergeVersion}).`,
-    )
+    );
   }
 
-  const beforeMergeWarnings = beforeMergeLighthouseReport.runWarnings
+  const beforeMergeWarnings = beforeMergeLighthouseReport.runWarnings;
   if (beforeMergeWarnings && beforeMergeWarnings.length) {
     warnings.push(
       `**Warning**: warnings produced while generating lighthouse report on \`${pullRequestBase}\`:
 - ${beforeMergeWarnings.join(`
 - `)}`,
-    )
+    );
   }
-  const afterMergeWarnings = afterMergeLighthouseReport.runWarnings
+  const afterMergeWarnings = afterMergeLighthouseReport.runWarnings;
   if (afterMergeWarnings && afterMergeWarnings.length) {
     warnings.push(
       `**Warning**: warnings produced while generating lighthouse report after merge:
 - ${afterMergeWarnings.join(`
 - `)}`,
-    )
+    );
   }
 
   const bodyLines = [
@@ -66,13 +66,13 @@ ${renderBody({
           }),
         ]
       : []),
-  ]
+  ];
 
   const body = bodyLines.join(`
-`)
+`);
 
-  return { warnings, body }
-}
+  return { warnings, body };
+};
 
 const renderBody = ({
   beforeMergeLighthouseReport,
@@ -87,12 +87,12 @@ const renderBody = ({
         afterMergeLighthouseReport,
         pullRequestBase,
         pullRequestHead,
-      })
+      });
     },
   ).join(`
 
-`)
-}
+`);
+};
 
 const renderCategory = (
   category,
@@ -100,14 +100,14 @@ const renderCategory = (
 ) => {
   const beforeMergeDisplayedScore = scoreToDisplayedScore(
     beforeMergeLighthouseReport.categories[category].score,
-  )
+  );
   const afterMergeDisplayedScore = scoreToDisplayedScore(
     afterMergeLighthouseReport.categories[category].score,
-  )
-  const diff = afterMergeDisplayedScore - beforeMergeDisplayedScore
-  const diffDisplayValue = diff === 0 ? "no impact" : formatNumericDiff(diff)
+  );
+  const diff = afterMergeDisplayedScore - beforeMergeDisplayedScore;
+  const diffDisplayValue = diff === 0 ? "no impact" : formatNumericDiff(diff);
 
-  const summaryText = `${category} score: ${afterMergeDisplayedScore} (${diffDisplayValue})`
+  const summaryText = `${category} score: ${afterMergeDisplayedScore} (${diffDisplayValue})`;
 
   return `<details>
   <summary>${summaryText}</summary>
@@ -120,28 +120,28 @@ const renderCategory = (
     beforeMergeLighthouseReport,
     afterMergeLighthouseReport,
   })}
-</details>`
-}
+</details>`;
+};
 
 const scoreToDisplayedScore = (floatingNumber) =>
-  Math.round(floatingNumber * 100)
+  Math.round(floatingNumber * 100);
 
 const renderCategoryAudits = (
   category,
   { beforeMergeLighthouseReport, afterMergeLighthouseReport },
 ) => {
-  const { auditRefs } = afterMergeLighthouseReport.categories[category]
-  const audits = []
+  const { auditRefs } = afterMergeLighthouseReport.categories[category];
+  const audits = [];
   auditRefs.forEach((auditRef) => {
-    const auditId = auditRef.id
-    const beforeMergeAudit = beforeMergeLighthouseReport.audits[auditId]
-    const afterMergeAudit = afterMergeLighthouseReport.audits[auditId]
-    const beforeMergeAuditOutput = renderAudit(beforeMergeAudit)
-    const afterMergeAuditOutput = renderAudit(afterMergeAudit)
+    const auditId = auditRef.id;
+    const beforeMergeAudit = beforeMergeLighthouseReport.audits[auditId];
+    const afterMergeAudit = afterMergeLighthouseReport.audits[auditId];
+    const beforeMergeAuditOutput = renderAudit(beforeMergeAudit);
+    const afterMergeAuditOutput = renderAudit(afterMergeAudit);
 
     // both are not applicable
     if (beforeMergeAuditOutput === null && afterMergeAuditOutput === null) {
-      return
+      return;
     }
 
     // becomes applicable
@@ -151,8 +151,8 @@ const renderCategoryAudits = (
         `<td nowrap>---</td>`,
         `<td nowrap>---</td>`,
         `<td nowrap>${afterMergeAuditOutput}</td>`,
-      ])
-      return
+      ]);
+      return;
     }
 
     // becomes unapplicable
@@ -162,23 +162,23 @@ const renderCategoryAudits = (
         `<td nowrap>---</td>`,
         `<td nowrap>${beforeMergeAuditOutput}</td>`,
         `<td nowrap>---</td>`,
-      ])
-      return
+      ]);
+      return;
     }
 
     if (
       typeof beforeMergeAuditOutput === "number" &&
       typeof afterMergeAuditOutput === "number"
     ) {
-      const diff = afterMergeAuditOutput - beforeMergeAuditOutput
+      const diff = afterMergeAuditOutput - beforeMergeAuditOutput;
 
       audits.push([
         `<td nowrap>${auditId}</td>`,
         `<td nowrap>${diff === 0 ? "none" : formatNumericDiff(diff)}</td>`,
         `<td nowrap>${beforeMergeAuditOutput}</td>`,
         `<td nowrap>${afterMergeAuditOutput}</td>`,
-      ])
-      return
+      ]);
+      return;
     }
 
     audits.push([
@@ -188,8 +188,8 @@ const renderCategoryAudits = (
       }</td>`,
       `<td nowrap>${beforeMergeAuditOutput}</td>`,
       `<td nowrap>${afterMergeAuditOutput}</td>`,
-    ])
-  })
+    ]);
+  });
 
   return `
   <table>
@@ -211,46 +211,46 @@ const renderCategoryAudits = (
       <tr>`)}
       </tr>
     </tbody>
-  </table>`
-}
+  </table>`;
+};
 
 const renderAudit = (audit) => {
-  const { scoreDisplayMode } = audit
+  const { scoreDisplayMode } = audit;
 
   if (scoreDisplayMode === "manual") {
-    return null
+    return null;
   }
 
   if (scoreDisplayMode === "notApplicable") {
-    return null
+    return null;
   }
 
   if (scoreDisplayMode === "informative") {
-    const { displayValue } = audit
-    if (typeof displayValue !== "undefined") return displayValue
+    const { displayValue } = audit;
+    if (typeof displayValue !== "undefined") return displayValue;
 
-    const { numericValue } = audit
-    if (typeof numericValue !== "undefined") return numericValue
+    const { numericValue } = audit;
+    if (typeof numericValue !== "undefined") return numericValue;
 
-    return null
+    return null;
   }
 
   if (scoreDisplayMode === "binary") {
-    const { score } = audit
-    return score ? "✔" : "☓"
+    const { score } = audit;
+    return score ? "✔" : "☓";
   }
 
   if (scoreDisplayMode === "numeric") {
-    const { score } = audit
-    return scoreToDisplayedScore(score)
+    const { score } = audit;
+    return scoreToDisplayedScore(score);
   }
 
   if (scoreDisplayMode === "error") {
-    return "error"
+    return "error";
   }
 
-  return null
-}
+  return null;
+};
 
 const renderGistLinks = ({
   beforeMergeGist,
@@ -263,9 +263,9 @@ const renderGistLinks = ({
   )}">${pullRequestBase} report</a> and <a href="${gistIdToReportUrl(
     afterMergeGist.id,
   )}">report after merge</a>
-</sub><br />`
-}
+</sub><br />`;
+};
 
 const gistIdToReportUrl = (gistId) => {
-  return `https://googlechrome.github.io/lighthouse/viewer/?gist=${gistId}`
-}
+  return `https://googlechrome.github.io/lighthouse/viewer/?gist=${gistId}`;
+};

package/src/pr_impact/formatNumericDiff.js

@@ -1,14 +1,14 @@
-const enDecimalFormatter = new Intl.NumberFormat("en", { style: "decimal" })
+const enDecimalFormatter = new Intl.NumberFormat("en", { style: "decimal" });
 
 export const formatNumericDiff = (valueAsNumber) => {
-  const valueAsAbsoluteNumber = Math.abs(valueAsNumber)
-  const valueAsString = enDecimalFormatter.format(valueAsAbsoluteNumber)
+  const valueAsAbsoluteNumber = Math.abs(valueAsNumber);
+  const valueAsString = enDecimalFormatter.format(valueAsAbsoluteNumber);
 
   if (valueAsNumber < 0) {
-    return `-${valueAsString}`
+    return `-${valueAsString}`;
   }
   if (valueAsNumber > 0) {
-    return `+${valueAsString}`
+    return `+${valueAsString}`;
   }
-  return valueAsString
-}
+  return valueAsString;
+};

package/src/pr_impact/jsenvCommentParameters.js

@@ -1 +1 @@
-export const jsenvCommentParameters = {}
+export const jsenvCommentParameters = {};

package/src/pr_impact/patchOrPostGists.js

@@ -1,5 +1,5 @@
-import * as githubRESTAPI from "@jsenv/github-pull-request-impact/src/internal/github_rest_api.js"
-import { createDetailedMessage } from "@jsenv/log"
+import * as githubRESTAPI from "@jsenv/github-pull-request-impact/src/internal/github_rest_api.js";
+import { createDetailedMessage } from "@jsenv/log";
 
 // https://developer.github.com/v3/gists/#create-a-gist
 
@@ -15,14 +15,14 @@ export const patchOrPostGists = async ({
   afterMergeLighthouseReport,
   existingComment,
 }) => {
-  let beforeMergeGistId
-  let afterMergeGistId
+  let beforeMergeGistId;
+  let afterMergeGistId;
 
   if (existingComment) {
-    const gistIds = gistIdsFromComment(existingComment)
+    const gistIds = gistIdsFromComment(existingComment);
     if (gistIds) {
-      beforeMergeGistId = gistIds.beforeMergeGistId
-      afterMergeGistId = gistIds.afterMergeGistId
+      beforeMergeGistId = gistIds.beforeMergeGistId;
+      afterMergeGistId = gistIds.afterMergeGistId;
       logger.debug(
         createDetailedMessage(`gists found in comment body`, {
           "before merging gist with lighthouse report":
@@ -30,13 +30,13 @@ export const patchOrPostGists = async ({
           "after merging gist with lighthouse report":
             gistIdToUrl(afterMergeGistId),
         }),
-      )
+      );
     } else {
-      logger.debug(`cannot find gist id in comment body`)
+      logger.debug(`cannot find gist id in comment body`);
     }
   }
 
-  logger.debug(`update or create both gists.`)
+  logger.debug(`update or create both gists.`);
   let [beforeMergeGist, afterMergeGist] = await Promise.all([
     beforeMergeGistId
       ? githubRESTAPI.GET({
@@ -50,30 +50,30 @@ export const patchOrPostGists = async ({
           githubToken,
         })
       : null,
-  ])
+  ]);
 
   const beforeMergeGistBody = createGistBody(beforeMergeLighthouseReport, {
     repositoryOwner,
     repositoryName,
     pullRequestNumber,
     beforeMerge: true,
-  })
+  });
   if (beforeMergeGist) {
-    logger.info(`updating base gist at ${gistIdToUrl(beforeMergeGist.id)}`)
+    logger.info(`updating base gist at ${gistIdToUrl(beforeMergeGist.id)}`);
     beforeMergeGist = await githubRESTAPI.PATCH({
       url: `https://api.github.com/gists/${beforeMergeGist.id}`,
       githubToken,
       body: beforeMergeGistBody,
-    })
-    logger.info(`base gist updated`)
+    });
+    logger.info(`base gist updated`);
   } else {
-    logger.info(`creating base gist`)
+    logger.info(`creating base gist`);
     beforeMergeGist = await githubRESTAPI.POST({
       url: `https://api.github.com/gists`,
       githubToken,
       body: beforeMergeGistBody,
-    })
-    logger.info(`base gist created at ${gistIdToUrl(beforeMergeGist.id)}`)
+    });
+    logger.info(`base gist created at ${gistIdToUrl(beforeMergeGist.id)}`);
   }
 
   const afterMergeGistBody = createGistBody(afterMergeLighthouseReport, {
@@ -81,32 +81,34 @@ export const patchOrPostGists = async ({
     repositoryName,
     pullRequestNumber,
     beforeMerge: false,
-  })
+  });
   if (afterMergeGist) {
     logger.info(
       `updating after merge gist at ${gistIdToUrl(afterMergeGist.id)}`,
-    )
+    );
     afterMergeGist = await githubRESTAPI.PATCH({
       url: `https://api.github.com/gists/${afterMergeGist.id}`,
       githubToken,
       body: afterMergeGistBody,
-    })
-    logger.info(`after merge gist updated`)
+    });
+    logger.info(`after merge gist updated`);
   } else {
-    logger.info(`creating after merge gist`)
+    logger.info(`creating after merge gist`);
     afterMergeGist = await githubRESTAPI.POST({
       url: `https://api.github.com/gists`,
       githubToken,
       body: afterMergeGistBody,
-    })
-    logger.info(`after merge gist created at ${gistIdToUrl(afterMergeGist.id)}`)
+    });
+    logger.info(
+      `after merge gist created at ${gistIdToUrl(afterMergeGist.id)}`,
+    );
   }
 
   return {
     beforeMergeGist,
     afterMergeGist,
-  }
-}
+  };
+};
 
 const createGistBody = (
   lighthouseReport,
@@ -121,35 +123,35 @@ const createGistBody = (
       },
     },
     public: false,
-  }
-}
+  };
+};
 
 const beforeMergeGistIdRegex = new RegExp(
   "<!-- before_merge_gist_id=([a-zA-Z0-9_]+) -->",
-)
+);
 const afterMergeGistIdRegex = new RegExp(
   "<!-- after_merge_gist_id=([a-zA-Z0-9_]+) -->",
-)
+);
 
 const gistIdsFromComment = (comment) => {
-  const beforeMergeGistIdMatch = comment.body.match(beforeMergeGistIdRegex)
+  const beforeMergeGistIdMatch = comment.body.match(beforeMergeGistIdRegex);
   if (!beforeMergeGistIdMatch) {
-    return null
+    return null;
   }
 
-  const afterMergeGistIdMatch = comment.body.match(afterMergeGistIdRegex)
+  const afterMergeGistIdMatch = comment.body.match(afterMergeGistIdRegex);
   if (!afterMergeGistIdMatch) {
-    return null
+    return null;
   }
 
-  const beforeMergeGistId = beforeMergeGistIdMatch[1]
-  const afterMergeGistId = afterMergeGistIdMatch[1]
+  const beforeMergeGistId = beforeMergeGistIdMatch[1];
+  const afterMergeGistId = afterMergeGistIdMatch[1];
   return {
     beforeMergeGistId,
     afterMergeGistId,
-  }
-}
+  };
+};
 
 const gistIdToUrl = (gistId) => {
-  return `https://gist.github.com/${gistId}`
-}
+  return `https://gist.github.com/${gistId}`;
+};

package/src/report_lighthouse_impact_in_github_pr.js

@@ -1,9 +1,9 @@
-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 { patchOrPostGists } from "./pr_impact/patchOrPostGists.js"
-import { createLighthouseImpactComment } from "./pr_impact/createLighthouseImpactComment.js"
+import { patchOrPostGists } from "./pr_impact/patchOrPostGists.js";
+import { createLighthouseImpactComment } from "./pr_impact/createLighthouseImpactComment.js";
 
 export const reportLighthouseImpactInGithubPullRequest = async ({
   logLevel,
@@ -23,14 +23,14 @@ export const reportLighthouseImpactInGithubPullRequest = async ({
   catchError,
   skipGistWarning = false,
 }) => {
-  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
+  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl);
   if (typeof lighthouseReportUrl === "string") {
-    lighthouseReportUrl = new URL(lighthouseReportUrl, rootDirectoryUrl).href
+    lighthouseReportUrl = new URL(lighthouseReportUrl, rootDirectoryUrl).href;
   } else if (lighthouseReportUrl instanceof URL) {
   } else {
     throw new TypeError(
       `lighthouseReportUrl must be a string or an url but received ${lighthouseReportUrl}`,
-    )
+    );
   }
 
   return commentGitHubPullRequestImpact({
@@ -47,11 +47,11 @@ export const reportLighthouseImpactInGithubPullRequest = async ({
     pullRequestNumber,
 
     collectInfo: async ({ execCommandInRootDirectory }) => {
-      await execCommandInRootDirectory(installCommand)
+      await execCommandInRootDirectory(installCommand);
       const lighthouseReport = await importOneExportFromFile(
         lighthouseReportUrl,
-      )
-      return { version: 1, data: lighthouseReport }
+      );
+      return { version: 1, data: lighthouseReport };
     },
     commentIdentifier: `<!-- Generated by @jsenv/lighthouse-impact -->`,
     createCommentForComparison: async ({
@@ -63,10 +63,10 @@ export const reportLighthouseImpactInGithubPullRequest = async ({
       afterMergeData,
       existingComment,
     }) => {
-      const gistWarnings = []
+      const gistWarnings = [];
 
-      let beforeMergeGist
-      let afterMergeGist
+      let beforeMergeGist;
+      let afterMergeGist;
       try {
         const gistResult = await patchOrPostGists({
           logger,
@@ -79,18 +79,18 @@ export const reportLighthouseImpactInGithubPullRequest = async ({
           beforeMergeLighthouseReport: beforeMergeData,
           afterMergeLighthouseReport: afterMergeData,
           existingComment,
-        })
-        beforeMergeGist = gistResult.beforeMergeGist
-        afterMergeGist = gistResult.afterMergeGist
+        });
+        beforeMergeGist = gistResult.beforeMergeGist;
+        afterMergeGist = gistResult.afterMergeGist;
       } catch (e) {
         if (e.responseStatus === 403) {
           if (!skipGistWarning) {
             gistWarnings.push(
               `**Warning:** Link to lighthouse reports cannot be generated because github token is not allowed to create gists.`,
-            )
+            );
           }
         } else {
-          throw e
+          throw e;
         }
       }
 
@@ -101,12 +101,12 @@ export const reportLighthouseImpactInGithubPullRequest = async ({
         afterMergeLighthouseReport: afterMergeData,
         beforeMergeGist,
         afterMergeGist,
-      })
+      });
 
       return {
         warnings: [...gistWarnings, ...comment.warnings],
         body: comment.body,
-      }
+      };
     },
     generatedByLink: {
       url: "https://github.com/jsenv/workflow/tree/main/packages/lighthouse-impact",
@@ -115,5 +115,5 @@ export const reportLighthouseImpactInGithubPullRequest = async ({
     runLink,
     commitInGeneratedByInfo,
     catchError,
-  })
-}
+  });
+};

package/src/run_lighthouse_on_playwright_page.js

@@ -1,60 +1,61 @@
-import { generateLighthouseReport } from "./generate/generate_lighthouse_report.js"
+import { generateLighthouseReport } from "./generate/generate_lighthouse_report.js";
 
 export const runLighthouseOnPlaywrightPage = async (
   page,
   { chromiumDebuggingPort, ...options },
 ) => {
-  const url = page.url()
+  const url = page.url();
   const userAgent = await page.evaluate(() => {
     /* eslint-disable no-undef */
-    return navigator.userAgent
+    return navigator.userAgent;
     /* eslint-enable no-undef */
-  })
+  });
   const deviceScaleFactor = await page.evaluate(() => {
     /* eslint-disable no-undef */
-    return window.devicePixelRatio
+    return window.devicePixelRatio;
     /* eslint-enable no-undef */
-  })
+  });
   const { screenWidth, screenHeight } = await page.evaluate(() => {
     /* eslint-disable no-undef */
     return {
       screenWidth: window.screen.width,
       screenHeight: window.screen.height,
-    }
+    };
     /* eslint-enable no-undef */
-  })
+  });
   // see "isMobile" into https://playwright.dev/docs/api/class-browser#browser-new-context
   const viewportMetaTakenIntoAccount = await page.evaluate(() => {
     /* eslint-disable no-undef */
-    let mutate
-    const viewportWidthNow = window.innerWidth
-    const viewportMeta = document.head.querySelector("meta[name=viewport]")
+    let mutate;
+    const viewportWidthNow = window.innerWidth;
+    const viewportMeta = document.head.querySelector("meta[name=viewport]");
     if (viewportMeta) {
       mutate = () => {
-        const content = viewportMeta.content
-        viewportMeta.setAttribute("content", `width=${viewportWidthNow + 1}`)
+        const content = viewportMeta.content;
+        viewportMeta.setAttribute("content", `width=${viewportWidthNow + 1}`);
         return () => {
-          viewportMeta.setAttribute("content", content)
-        }
-      }
+          viewportMeta.setAttribute("content", content);
+        };
+      };
     } else {
       mutate = () => {
-        const viewportMeta = document.createElement("meta")
-        viewportMeta.name = "viewport"
-        viewportMeta.setAttribute("content", `width=${viewportWidthNow + 1}`)
-        document.head.appendChild(viewportMeta)
+        const viewportMeta = document.createElement("meta");
+        viewportMeta.name = "viewport";
+        viewportMeta.setAttribute("content", `width=${viewportWidthNow + 1}`);
+        document.head.appendChild(viewportMeta);
         return () => {
-          document.head.removeChild(viewportMeta)
-        }
-      }
+          document.head.removeChild(viewportMeta);
+        };
+      };
     }
-    const cleanup = mutate()
-    const viewportWidthAfter = window.innerWidth
-    cleanup()
-    const viewportMetaTakenIntoAccount = viewportWidthAfter !== viewportWidthNow
-    return viewportMetaTakenIntoAccount
+    const cleanup = mutate();
+    const viewportWidthAfter = window.innerWidth;
+    cleanup();
+    const viewportMetaTakenIntoAccount =
+      viewportWidthAfter !== viewportWidthNow;
+    return viewportMetaTakenIntoAccount;
     /* eslint-enable no-undef */
-  })
+  });
 
   const report = await generateLighthouseReport(url, {
     chromiumDebuggingPort,
@@ -64,6 +65,6 @@ export const runLighthouseOnPlaywrightPage = async (
     emulatedMobile: viewportMetaTakenIntoAccount,
     emulatedUserAgent: userAgent,
     ...options,
-  })
-  return report
-}
+  });
+  return report;
+};