lighthouse-reporting 1.0.0

package/README.md

@@ -0,0 +1,13 @@
+# lighthouse-reporting
+
+> Generate Lighthouse reports in HTML, CSV, and JSON formats, optimized for publishing in Jenkins or GitHub Actions.
+
+The reports include trend history support, allowing you to track performance improvements over time.
+
+## Usage
+
+### Jenkins
+
+### GitHub Actions
+
+TODO

package/dist/constants-226e9774.js

@@ -0,0 +1,8 @@
+const INDEX_HTML = "index.html";
+const LH_OUT_DIR = "lighthouse";
+const PW_TMP_DIR = "pwlh";
+export {
+  INDEX_HTML as I,
+  LH_OUT_DIR as L,
+  PW_TMP_DIR as P
+};

package/dist/constants-667b8033.cjs

@@ -0,0 +1,7 @@
+"use strict";
+const INDEX_HTML = "index.html";
+const LH_OUT_DIR = "lighthouse";
+const PW_TMP_DIR = "pwlh";
+exports.INDEX_HTML = INDEX_HTML;
+exports.LH_OUT_DIR = LH_OUT_DIR;
+exports.PW_TMP_DIR = PW_TMP_DIR;

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const INDEX_HTML = "index.html";
+export declare const LH_OUT_DIR = "lighthouse";
+export declare const PW_TMP_DIR = "pwlh";

package/dist/hooks.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const os = require("os");
+const path = require("path");
+const fse = require("fs-extra");
+const url = require("url");
+const constants = require("./constants-667b8033.cjs");
+let dirname;
+if (typeof __dirname !== "string") {
+  const filename = url.fileURLToPath(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : document.currentScript && document.currentScript.src || new URL("hooks.cjs", document.baseURI).href);
+  dirname = path.dirname(filename);
+} else {
+  dirname = __dirname;
+}
+const reportDir = path.join(process.cwd(), process.env.LH_REPORT_DIR || constants.LH_OUT_DIR);
+const htmlTemplatePath = path.join(dirname, "lighthouse.html");
+async function lighthouseSetup() {
+  await fse.ensureDir(reportDir);
+  await fse.copyFile(htmlTemplatePath, path.join(reportDir, constants.INDEX_HTML));
+}
+async function lighthousePlaywrightTeardown() {
+  await fse.remove(path.join(os.tmpdir(), constants.PW_TMP_DIR));
+}
+exports.lighthousePlaywrightTeardown = lighthousePlaywrightTeardown;
+exports.lighthouseSetup = lighthouseSetup;

package/dist/hooks.d.ts

@@ -0,0 +1,2 @@
+export declare function lighthouseSetup(): Promise<void>;
+export declare function lighthousePlaywrightTeardown(): Promise<void>;

package/dist/hooks.js

@@ -0,0 +1,25 @@
+import os from "os";
+import path from "path";
+import fse from "fs-extra";
+import url from "url";
+import { L as LH_OUT_DIR, I as INDEX_HTML, P as PW_TMP_DIR } from "./constants-226e9774.js";
+let dirname;
+if (typeof __dirname !== "string") {
+  const filename = url.fileURLToPath(import.meta.url);
+  dirname = path.dirname(filename);
+} else {
+  dirname = __dirname;
+}
+const reportDir = path.join(process.cwd(), process.env.LH_REPORT_DIR || LH_OUT_DIR);
+const htmlTemplatePath = path.join(dirname, "lighthouse.html");
+async function lighthouseSetup() {
+  await fse.ensureDir(reportDir);
+  await fse.copyFile(htmlTemplatePath, path.join(reportDir, INDEX_HTML));
+}
+async function lighthousePlaywrightTeardown() {
+  await fse.remove(path.join(os.tmpdir(), PW_TMP_DIR));
+}
+export {
+  lighthousePlaywrightTeardown,
+  lighthouseSetup
+};

package/dist/index.cjs

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const hooks = require("./hooks.cjs");
+const lighthouseReports = require("./lighthouseReports.cjs");
+const lighthouseTest = require("./lighthouseTest.cjs");
+require("os");
+require("path");
+require("fs-extra");
+require("url");
+require("./constants-667b8033.cjs");
+require("get-port");
+require("@playwright/test");
+exports.lighthousePlaywrightTeardown = hooks.lighthousePlaywrightTeardown;
+exports.lighthouseSetup = hooks.lighthouseSetup;
+exports.getScores = lighthouseReports.getScores;
+exports.writeCsvResult = lighthouseReports.writeCsvResult;
+exports.writeHtmlListEntryWithRetry = lighthouseReports.writeHtmlListEntryWithRetry;
+exports.lighthouseTest = lighthouseTest.lighthouseTest;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './hooks';
+export * from './lighthouseReports';
+export * from './lighthouseTest';

package/dist/index.js

@@ -0,0 +1,18 @@
+import { lighthousePlaywrightTeardown, lighthouseSetup } from "./hooks.js";
+import { getScores, writeCsvResult, writeHtmlListEntryWithRetry } from "./lighthouseReports.js";
+import { lighthouseTest } from "./lighthouseTest.js";
+import "os";
+import "path";
+import "fs-extra";
+import "url";
+import "./constants-226e9774.js";
+import "get-port";
+import "@playwright/test";
+export {
+  getScores,
+  lighthousePlaywrightTeardown,
+  lighthouseSetup,
+  lighthouseTest,
+  writeCsvResult,
+  writeHtmlListEntryWithRetry
+};

package/dist/lighthouse-reporting.umd.cjs

@@ -0,0 +1,202 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("os"), require("path"), require("fs-extra"), require("url"), require("net"), require("@playwright/test")) : typeof define === "function" && define.amd ? define(["exports", "os", "path", "fs-extra", "url", "net", "@playwright/test"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.lh_rep = {}, global.os, global.path, global.fse, global.url, global.net, global.test));
+})(this, function(exports2, os, path, fse, url, net, test) {
+  "use strict";
+  const INDEX_HTML = "index.html";
+  const LH_OUT_DIR = "lighthouse";
+  const PW_TMP_DIR = "pwlh";
+  let dirname;
+  if (typeof __dirname !== "string") {
+    const filename = url.fileURLToPath(typeof document === "undefined" && typeof location === "undefined" ? require("url").pathToFileURL(__filename).href : typeof document === "undefined" ? location.href : document.currentScript && document.currentScript.src || new URL("lighthouse-reporting.umd.cjs", document.baseURI).href);
+    dirname = path.dirname(filename);
+  } else {
+    dirname = __dirname;
+  }
+  const reportDir = path.join(process.cwd(), process.env.LH_REPORT_DIR || LH_OUT_DIR);
+  const htmlTemplatePath = path.join(dirname, "lighthouse.html");
+  async function lighthouseSetup() {
+    await fse.ensureDir(reportDir);
+    await fse.copyFile(htmlTemplatePath, path.join(reportDir, INDEX_HTML));
+  }
+  async function lighthousePlaywrightTeardown() {
+    await fse.remove(path.join(os.tmpdir(), PW_TMP_DIR));
+  }
+  const writeCsvResult = async (reportDir2, name, scores, thresholds, swimlanes = []) => {
+    let csvData = Object.keys(scores).join(",");
+    if (swimlanes.length > 0) {
+      csvData += "," + swimlanes.map((swimlane) => `${swimlane}_threshold`);
+    }
+    csvData += "\n";
+    csvData += Object.values(scores).join(",");
+    if (swimlanes.length > 0) {
+      csvData += "," + swimlanes.map((swimlane) => thresholds[swimlane]);
+    }
+    await fse.writeFile(path.join(reportDir2, `${name}.csv`), csvData);
+  };
+  const writeHtmlListEntry = async (htmlFilePath, name, scores, thresholds, error, addReportLink) => {
+    const htmlFileData = (await fse.readFile(htmlFilePath)).toString("utf-8").split("\n");
+    const insertIdx = htmlFileData.findIndex((v) => v.includes("// lighthouse-page-results"));
+    if (insertIdx < 0) {
+      throw new Error("Failed to write results to index.html");
+    }
+    htmlFileData.splice(insertIdx + 1, 0, JSON.stringify({ href: `${name}.html`, name, scores, thresholds, error, addReportLink }) + ",");
+    await fse.writeFile(htmlFilePath, htmlFileData.join("\n"));
+  };
+  const writeHtmlListEntryWithRetry = async (htmlFilePath, name, scores, thresholds, comparisonError, addReportLink = true) => {
+    let attempts = 10;
+    let error;
+    while (attempts > 0) {
+      attempts--;
+      try {
+        await writeHtmlListEntry(htmlFilePath, name, scores, thresholds, comparisonError, addReportLink);
+        return;
+      } catch (e) {
+        error = e;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    throw error;
+  };
+  const getScores = (result) => Object.entries(result.lhr.categories).reduce((prev, [key, c]) => {
+    prev[key] = Math.floor(c.score * 100);
+    return prev;
+  }, {});
+  class Locked extends Error {
+    constructor(port) {
+      super(`${port} is locked`);
+    }
+  }
+  const lockedPorts = {
+    old: /* @__PURE__ */ new Set(),
+    young: /* @__PURE__ */ new Set()
+  };
+  const releaseOldLockedPortsIntervalMs = 1e3 * 15;
+  let interval;
+  const getLocalHosts = () => {
+    const interfaces = os.networkInterfaces();
+    const results = /* @__PURE__ */ new Set([void 0, "0.0.0.0"]);
+    for (const _interface of Object.values(interfaces)) {
+      for (const config of _interface) {
+        results.add(config.address);
+      }
+    }
+    return results;
+  };
+  const checkAvailablePort = (options) => new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.on("error", reject);
+    server.listen(options, () => {
+      const { port } = server.address();
+      server.close(() => {
+        resolve(port);
+      });
+    });
+  });
+  const getAvailablePort = async (options, hosts) => {
+    if (options.host || options.port === 0) {
+      return checkAvailablePort(options);
+    }
+    for (const host of hosts) {
+      try {
+        await checkAvailablePort({ port: options.port, host });
+      } catch (error) {
+        if (!["EADDRNOTAVAIL", "EINVAL"].includes(error.code)) {
+          throw error;
+        }
+      }
+    }
+    return options.port;
+  };
+  const portCheckSequence = function* (ports) {
+    if (ports) {
+      yield* ports;
+    }
+    yield 0;
+  };
+  async function getPorts(options) {
+    let ports;
+    let exclude = /* @__PURE__ */ new Set();
+    if (options) {
+      if (options.port) {
+        ports = typeof options.port === "number" ? [options.port] : options.port;
+      }
+      if (options.exclude) {
+        const excludeIterable = options.exclude;
+        if (typeof excludeIterable[Symbol.iterator] !== "function") {
+          throw new TypeError("The `exclude` option must be an iterable.");
+        }
+        for (const element of excludeIterable) {
+          if (typeof element !== "number") {
+            throw new TypeError("Each item in the `exclude` option must be a number corresponding to the port you want excluded.");
+          }
+          if (!Number.isSafeInteger(element)) {
+            throw new TypeError(`Number ${element} in the exclude option is not a safe integer and can't be used`);
+          }
+        }
+        exclude = new Set(excludeIterable);
+      }
+    }
+    if (interval === void 0) {
+      interval = setInterval(() => {
+        lockedPorts.old = lockedPorts.young;
+        lockedPorts.young = /* @__PURE__ */ new Set();
+      }, releaseOldLockedPortsIntervalMs);
+      if (interval.unref) {
+        interval.unref();
+      }
+    }
+    const hosts = getLocalHosts();
+    for (const port of portCheckSequence(ports)) {
+      try {
+        if (exclude.has(port)) {
+          continue;
+        }
+        let availablePort = await getAvailablePort({ ...options, port }, hosts);
+        while (lockedPorts.old.has(availablePort) || lockedPorts.young.has(availablePort)) {
+          if (port !== 0) {
+            throw new Locked(port);
+          }
+          availablePort = await getAvailablePort({ ...options, port }, hosts);
+        }
+        lockedPorts.young.add(availablePort);
+        return availablePort;
+      } catch (error) {
+        if (!["EADDRINUSE", "EACCES"].includes(error.code) && !(error instanceof Locked)) {
+          throw error;
+        }
+      }
+    }
+    throw new Error("No available ports found");
+  }
+  const lighthouseTest = test.test.extend({
+    port: [
+      // eslint-disable-next-line no-empty-pattern
+      async ({}, use) => {
+        const port = await getPorts();
+        await use(port);
+      },
+      { scope: "worker" }
+    ],
+    context: [
+      async ({ port, launchOptions }, use) => {
+        const context = await test.chromium.launchPersistentContext(
+          path.join(os.tmpdir(), PW_TMP_DIR, `${Math.random()}`.replace(".", "")),
+          {
+            args: [...launchOptions.args || [], `--remote-debugging-port=${port}`]
+          }
+        );
+        await use(context);
+        await context.close();
+      },
+      { scope: "test" }
+    ]
+  });
+  exports2.getScores = getScores;
+  exports2.lighthousePlaywrightTeardown = lighthousePlaywrightTeardown;
+  exports2.lighthouseSetup = lighthouseSetup;
+  exports2.lighthouseTest = lighthouseTest;
+  exports2.writeCsvResult = writeCsvResult;
+  exports2.writeHtmlListEntryWithRetry = writeHtmlListEntryWithRetry;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+});

package/dist/lighthouse.html

@@ -0,0 +1,187 @@
+<!DOCTYPE html>
+<html lang="en">
+    <title>Lighthouse Results</title>
+    <head>
+        <meta charset="utf-8" />
+        <title>Lighthouse</title>
+        <style>
+            body {
+                margin: 0px;
+                font-size: 0.9em;
+                font-family: sans-serif;
+            }
+            iframe {
+                display: block;
+                border: none;
+                height: 100vh;
+                width: 100vw;
+            }
+
+            #table-filter {
+                margin: 10px;
+            }
+
+            #scrollTop {
+                margin: 0 10px;
+            }
+
+            #lhTable {
+                border-collapse: collapse;
+                margin: 10px;
+                box-shadow: 0 0 20px rgba(0, 0, 0, 0.15);
+            }
+            .hide,
+            #lhTable.hide-passed tbody > tr:not(.has-error) {
+                display: none;
+            }
+            #lhTable .lh-fail {
+                color: #a51515;
+            }
+            #lhTable .lh-pass {
+                color: #008000;
+            }
+            #lhTable thead tr {
+                background-color: #4c90e2;
+                color: #ffffff;
+                text-align: left;
+            }
+            #lhTable th,
+            #lhTable td {
+                padding: 12px 15px;
+            }
+            #lhTable tbody tr {
+                border-bottom: 1px solid #dddddd;
+            }
+            #lhTable tbody tr:nth-of-type(even) {
+                background-color: #f3f3f3;
+            }
+            #lhTable tbody tr:hover {
+                background-color: #b7d2f3;
+            }
+            #lhTable tfoot tr {
+                border-top: 2px solid #4c90e2;
+                font-weight: bold;
+            }
+        </style>
+    </head>
+    <body>
+        <div id="table-filter">
+            <label for="showPassed"><input type="checkbox" name="showPassed" id="showPassed" />Show passed?</label>
+        </div>
+
+        <table id="lhTable" class="hide-passed">
+            <thead></thead>
+            <tbody></tbody>
+            <tfoot></tfoot>
+        </table>
+
+        <button id="scrollTop" class="hide" aria-label="Scroll Top" title="Close Lighthouse report and scroll top">Scroll Top</button>
+
+        <iframe id="lh-iframe" height="100%" width="100%" frameborder="0" src="" title="Lighthouse report"></iframe>
+    </body>
+    <script type="text/javascript">
+        window.onbeforeunload = () => window.scrollTo(0, 0)
+
+        const results = [
+            // lighthouse-page-results
+        ]
+
+        let sortKey
+        if (results.length > 0 && results[0].scores && typeof results[0].scores[Object.keys(results[0].scores).sort()[0]] === 'number') {
+            sortKey = Object.keys(results[0].scores).sort()[0]
+        }
+        results.sort((a, b) => {
+            if (sortKey) {
+                return a.scores[sortKey] - b.scores[sortKey]
+            }
+            return b.error ? 1 : -1
+        })
+
+        const createTr = (data, cellType = 'td', isError = false) => {
+            const row = document.createElement('tr')
+            if (isError) {
+                row.classList.add('has-error')
+            }
+            data.forEach((el) => {
+                const cell = document.createElement(cellType)
+                cell.appendChild(el)
+                row.appendChild(cell)
+            })
+            return row
+        }
+
+        const lhTable = document.getElementById('lhTable')
+
+        // header data
+        const lhTableHeader = lhTable.getElementsByTagName('thead')[0]
+        const headers = ['Result', ...Object.keys(results[0].scores), 'Page'].map((t) => document.createTextNode(t))
+        lhTableHeader.appendChild(createTr(headers, 'th'))
+
+        // footer data
+        const lhTableFooter = lhTable.getElementsByTagName('tfoot')[0]
+        lhTableFooter.appendChild(
+            createTr(
+                ['TOTAL', '', `Failed ${results.filter((r) => r.error).length} of ${results.length}`].map((t) => document.createTextNode(t))
+            )
+        )
+
+        // body data
+        const lhTableBody = lhTable.getElementsByTagName('tbody')[0]
+        results.forEach((r) => {
+            const rowData = []
+
+            // Result
+            const resultText = document.createElement('span')
+            resultText.classList.add(r.error ? 'lh-fail' : 'lh-pass')
+            resultText.appendChild(document.createTextNode(r.error ? 'FAIL' : 'PASS'))
+            rowData.push(resultText)
+
+            // Scores
+            Object.entries(r.scores).forEach(([k, v]) => {
+                rowData.push(document.createTextNode(`${v} (${r.thresholds[k]})`))
+            })
+
+            // Page
+            if (r.addReportLink) {
+                const link = document.createElement('a')
+                link.href = r.href
+                link.appendChild(document.createTextNode(r.name))
+                rowData.push(link)
+            } else {
+                rowData.push(document.createTextNode(r.name))
+            }
+
+            // append row to body
+            lhTableBody.appendChild(createTr(rowData, 'td', !!r.error))
+        })
+
+        const iframe = document.getElementById('lh-iframe')
+        const scrollTopButton = document.getElementById('scrollTop')
+
+        // add click listener to open specific lighthouse report
+        lhTableBody.addEventListener('click', (e) => {
+            if (e.target && e.target.nodeName == 'A') {
+                iframe.src = e.target.href
+                iframe.scrollIntoView({ behavior: 'smooth' })
+                scrollTopButton.classList.remove('hide')
+            }
+            e.preventDefault()
+            e.stopPropagation()
+        })
+
+        // scroll top
+        scrollTopButton.addEventListener('click', (e) => {
+            window.scrollTo({ top: 0, left: 0, behavior: 'smooth' })
+            iframe.src = ''
+            scrollTopButton.classList.add('hide')
+        })
+
+        // checkbox change listener to show/hide passed
+        document
+            .getElementById('table-filter')
+            .getElementsByTagName('input')[0]
+            .addEventListener('change', (e) => {
+                lhTable.classList.toggle('hide-passed')
+            })
+    </script>
+</html>

package/dist/lighthouseReports.cjs

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const path = require("path");
+const fse = require("fs-extra");
+const writeCsvResult = async (reportDir, name, scores, thresholds, swimlanes = []) => {
+  let csvData = Object.keys(scores).join(",");
+  if (swimlanes.length > 0) {
+    csvData += "," + swimlanes.map((swimlane) => `${swimlane}_threshold`);
+  }
+  csvData += "\n";
+  csvData += Object.values(scores).join(",");
+  if (swimlanes.length > 0) {
+    csvData += "," + swimlanes.map((swimlane) => thresholds[swimlane]);
+  }
+  await fse.writeFile(path.join(reportDir, `${name}.csv`), csvData);
+};
+const writeHtmlListEntry = async (htmlFilePath, name, scores, thresholds, error, addReportLink) => {
+  const htmlFileData = (await fse.readFile(htmlFilePath)).toString("utf-8").split("\n");
+  const insertIdx = htmlFileData.findIndex((v) => v.includes("// lighthouse-page-results"));
+  if (insertIdx < 0) {
+    throw new Error("Failed to write results to index.html");
+  }
+  htmlFileData.splice(insertIdx + 1, 0, JSON.stringify({ href: `${name}.html`, name, scores, thresholds, error, addReportLink }) + ",");
+  await fse.writeFile(htmlFilePath, htmlFileData.join("\n"));
+};
+const writeHtmlListEntryWithRetry = async (htmlFilePath, name, scores, thresholds, comparisonError, addReportLink = true) => {
+  let attempts = 10;
+  let error;
+  while (attempts > 0) {
+    attempts--;
+    try {
+      await writeHtmlListEntry(htmlFilePath, name, scores, thresholds, comparisonError, addReportLink);
+      return;
+    } catch (e) {
+      error = e;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  throw error;
+};
+const getScores = (result) => Object.entries(result.lhr.categories).reduce((prev, [key, c]) => {
+  prev[key] = Math.floor(c.score * 100);
+  return prev;
+}, {});
+exports.getScores = getScores;
+exports.writeCsvResult = writeCsvResult;
+exports.writeHtmlListEntryWithRetry = writeHtmlListEntryWithRetry;

package/dist/lighthouseReports.d.ts

@@ -0,0 +1,16 @@
+export interface LighthouseResult {
+    lhr: {
+        categories: {
+            [k: string]: {
+                score: number;
+            };
+        };
+    };
+    comparisonError?: string;
+}
+export declare const writeCsvResult: (reportDir: string, name: string, scores: Record<string, number>, thresholds: Record<string, number>, swimlanes?: Array<string>) => Promise<void>;
+/**
+ * workaround conflicts when multiple threads write the same file
+ */
+export declare const writeHtmlListEntryWithRetry: (htmlFilePath: string, name: string, scores: Record<string, number>, thresholds: Record<string, number>, comparisonError?: string, addReportLink?: boolean) => Promise<void>;
+export declare const getScores: (result: LighthouseResult) => Record<string, number>;

package/dist/lighthouseReports.js

@@ -0,0 +1,47 @@
+import path from "path";
+import fse from "fs-extra";
+const writeCsvResult = async (reportDir, name, scores, thresholds, swimlanes = []) => {
+  let csvData = Object.keys(scores).join(",");
+  if (swimlanes.length > 0) {
+    csvData += "," + swimlanes.map((swimlane) => `${swimlane}_threshold`);
+  }
+  csvData += "\n";
+  csvData += Object.values(scores).join(",");
+  if (swimlanes.length > 0) {
+    csvData += "," + swimlanes.map((swimlane) => thresholds[swimlane]);
+  }
+  await fse.writeFile(path.join(reportDir, `${name}.csv`), csvData);
+};
+const writeHtmlListEntry = async (htmlFilePath, name, scores, thresholds, error, addReportLink) => {
+  const htmlFileData = (await fse.readFile(htmlFilePath)).toString("utf-8").split("\n");
+  const insertIdx = htmlFileData.findIndex((v) => v.includes("// lighthouse-page-results"));
+  if (insertIdx < 0) {
+    throw new Error("Failed to write results to index.html");
+  }
+  htmlFileData.splice(insertIdx + 1, 0, JSON.stringify({ href: `${name}.html`, name, scores, thresholds, error, addReportLink }) + ",");
+  await fse.writeFile(htmlFilePath, htmlFileData.join("\n"));
+};
+const writeHtmlListEntryWithRetry = async (htmlFilePath, name, scores, thresholds, comparisonError, addReportLink = true) => {
+  let attempts = 10;
+  let error;
+  while (attempts > 0) {
+    attempts--;
+    try {
+      await writeHtmlListEntry(htmlFilePath, name, scores, thresholds, comparisonError, addReportLink);
+      return;
+    } catch (e) {
+      error = e;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  throw error;
+};
+const getScores = (result) => Object.entries(result.lhr.categories).reduce((prev, [key, c]) => {
+  prev[key] = Math.floor(c.score * 100);
+  return prev;
+}, {});
+export {
+  getScores,
+  writeCsvResult,
+  writeHtmlListEntryWithRetry
+};

package/dist/lighthouseTest.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const os = require("os");
+const path = require("path");
+const getPort = require("get-port");
+const test = require("@playwright/test");
+const constants = require("./constants-667b8033.cjs");
+const lighthouseTest = test.test.extend({
+  port: [
+    // eslint-disable-next-line no-empty-pattern
+    async ({}, use) => {
+      const port = await getPort();
+      await use(port);
+    },
+    { scope: "worker" }
+  ],
+  context: [
+    async ({ port, launchOptions }, use) => {
+      const context = await test.chromium.launchPersistentContext(
+        path.join(os.tmpdir(), constants.PW_TMP_DIR, `${Math.random()}`.replace(".", "")),
+        {
+          args: [...launchOptions.args || [], `--remote-debugging-port=${port}`]
+        }
+      );
+      await use(context);
+      await context.close();
+    },
+    { scope: "test" }
+  ]
+});
+exports.lighthouseTest = lighthouseTest;

package/dist/lighthouseTest.d.ts

@@ -0,0 +1,6 @@
+import type { BrowserContext } from '@playwright/test';
+export declare const lighthouseTest: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & {
+    context: BrowserContext;
+}, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions & {
+    port: number;
+}>;

package/dist/lighthouseTest.js

@@ -0,0 +1,31 @@
+import os from "os";
+import path from "path";
+import getPort from "get-port";
+import { test, chromium } from "@playwright/test";
+import { P as PW_TMP_DIR } from "./constants-226e9774.js";
+const lighthouseTest = test.extend({
+  port: [
+    // eslint-disable-next-line no-empty-pattern
+    async ({}, use) => {
+      const port = await getPort();
+      await use(port);
+    },
+    { scope: "worker" }
+  ],
+  context: [
+    async ({ port, launchOptions }, use) => {
+      const context = await chromium.launchPersistentContext(
+        path.join(os.tmpdir(), PW_TMP_DIR, `${Math.random()}`.replace(".", "")),
+        {
+          args: [...launchOptions.args || [], `--remote-debugging-port=${port}`]
+        }
+      );
+      await use(context);
+      await context.close();
+    },
+    { scope: "test" }
+  ]
+});
+export {
+  lighthouseTest
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "lighthouse-reporting",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "build": "vite build && vite build -c vite.umd.config.ts && tsc -p ./tsconfig.build.json",
+    "compile": "tsc",
+    "lint": "eslint --ext .ts --ignore-path .gitignore .",
+    "precommit": "run-p lint compile",
+    "semantic-release": "semantic-release"
+  },
+  "files": [
+    "dist/"
+  ],
+  "main": "./dist/lighthouse-reporting.umd.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/lighthouse-reporting.umd.cjs",
+      "default": "./dist/index.cjs"
+    }
+  },
+  "peerDependencies": {
+    "@playwright/test": "1"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.34.2",
+    "@types/fs-extra": "^11.0.1",
+    "@types/node": "^20.2.3",
+    "@typescript-eslint/eslint-plugin": "^5.59.7",
+    "@typescript-eslint/parser": "^5.59.7",
+    "eslint": "^8.41.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "husky": "^8.0.3",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.8.8",
+    "semantic-release": "^21.0.2",
+    "typescript": "^5.0.4",
+    "vite": "^4.3.8",
+    "vite-plugin-static-copy": "^0.15.0"
+  },
+  "dependencies": {
+    "fs-extra": "^11.1.1",
+    "get-port": "^6.1.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mgrybyk/lighthouse-reporting.git"
+  }
+}