lighthouse-badges 1.1.26 → 1.2.0

package/.eslintignore

@@ -1 +1,2 @@
-coverage/
+coverage/
+dist/

package/.eslintrc.yml

@@ -2,4 +2,5 @@ extends: airbnb-base
 env:
   jest: true
 rules:
-  no-underscore-dangle: warn
+  no-underscore-dangle: warn
+  import/no-import-module-exports: warn

package/.github/workflows/build.yml

@@ -14,20 +14,15 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Set up Docker Context for Buildx
-        id: buildx-context
-        run: docker context create builders
+        uses: actions/checkout@v3
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
+        uses: docker/setup-qemu-action@v2
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
+        uses: docker/setup-buildx-action@v2
         with:
           version: latest
-          endpoint: builders
 
       - name: Versions
         run: |
@@ -39,16 +34,17 @@ jobs:
         run: |
           npm install
           npm run lint
+          npm run build
 
       - name: Login to DockerHub
         if: github.ref == 'refs/heads/master'
-        uses: docker/login-action@v1 
+        uses: docker/login-action@v2
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Docker Build
-        uses: docker/build-push-action@v2
+        uses: docker/build-push-action@v3
         with:
           context: .
           file: ./Dockerfile
@@ -77,7 +73,7 @@ jobs:
           npm config set //npm.pkg.github.com/:_authToken ${GITHUB_TOKEN}
           [[ "$(npm show ${package_name} version)" ==  "${current_version}" ]] && \
             echo "Current version ${current_version} already published" || \
-            npm publish --ignore-scripts
+            npm run ci:publish
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -91,7 +87,7 @@ jobs:
           npm config set //registry.npmjs.org/:_authToken ${NPM_AUTH_TOKEN}
           [[ "$(npm show ${package_name} version)" ==  "${current_version}" ]] && \
             echo "Current version ${current_version} already published" || \
-            npm publish --ignore-scripts
+            npm run ci:publish
         env:
           NPM_AUTH_TOKEN: ${{ secrets.NPM_AUTH_TOKEN }}
 
@@ -101,7 +97,7 @@ jobs:
 
       - name: Deploy to Dockerhub
         if: github.ref == 'refs/heads/master'
-        uses: docker/build-push-action@v2
+        uses: docker/build-push-action@v3
         with:
           context: .
           file: ./Dockerfile

package/Dockerfile

@@ -15,15 +15,14 @@ LABEL maintainer="hello@mazzotta.me" \
     org.label-schema.version=$VERSION \
     org.label-schema.schema-version="1.0"
 
-# Update apk repositories & install chromium
-RUN apk --update --no-cache add chromium
+RUN apk --update --no-cache add chromium git
 
+# Add lighthouse
 RUN mkdir -p /home/lighthouse
 WORKDIR /home/lighthouse
+COPY dist/src /home/lighthouse/src
+COPY dist/package.json /home/lighthouse/package.json
 
-# Add lighthouse
-COPY src /home/lighthouse/src
-COPY package.json /home/lighthouse/package.json
 RUN npm install . && npm link && rm -rf /root/.npm
 
 # Set Chromium bin path

package/LICENSE.md

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018 Emanuele Mazzotta
+Copyright (c) 2023 Emanuele Mazzotta
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -54,7 +54,7 @@ Required arguments:
                         average score(s) of all the urls supplied, combined
 ```
 
-Additionally you can pass parameters to the lighthouse process directly via environment variable:
+Additionally, you can pass parameters to the lighthouse process directly via environment variable:
 
 ```bash
 # This will pass '--preset=desktop' to the lighthouse process

package/__tests__/argparser.js

@@ -1,12 +1,14 @@
-import { parser } from '../src/argparser';
+import parser from '../src/argparser';
 
 describe('test argparser', () => {
+  const baseUrl = 'https://emanuelemazzotta.com';
+
   it('should return expected default values', () => {
-    const actualArgs = parser.parse_args(['--urls', 'https://emanuelemazzotta.com', 'https://emanuelemazzotta.com/cv']);
+    const actualArgs = parser.parse_args(['--urls', baseUrl, `${baseUrl}/cv`]);
     expect(actualArgs.single_badge).toBe(false);
     expect(actualArgs.badge_style).toBe('flat');
     expect(actualArgs.save_report).toBe(false);
-    expect(actualArgs.urls).toStrictEqual(['https://emanuelemazzotta.com', 'https://emanuelemazzotta.com/cv']);
+    expect(actualArgs.urls).toStrictEqual([baseUrl, `${baseUrl}/cv`]);
   });
 
   it('should overwrite values', () => {
@@ -14,12 +16,12 @@ describe('test argparser', () => {
       '--single-badge',
       '--save-report',
       '--badge-style', 'flat-square',
-      '--urls', 'https://emanuelemazzotta.com',
+      '--urls', baseUrl,
     ]);
 
     expect(actualArgs.single_badge).toBe(true);
     expect(actualArgs.badge_style).toBe('flat-square');
     expect(actualArgs.save_report).toBe(true);
-    expect(actualArgs.urls).toStrictEqual(['https://emanuelemazzotta.com']);
+    expect(actualArgs.urls).toStrictEqual([baseUrl]);
   });
 });

package/__tests__/index.js

@@ -1,5 +1,5 @@
-import { parser } from '../src/argparser';
-import { handleUserInput } from '../src/index';
+import parser from '../src/argparser';
+import handleUserInput from '../src/index';
 import * as lighthouseBadges from '../src/lighthouse-badges';
 
 jest.mock('../src/lighthouse-badges');

package/__tests__/lighthouse-badges.js

@@ -1,12 +1,12 @@
 import fs from 'fs';
-import ReportGenerator from 'lighthouse/report/generator/report-generator';
-import lighthouseBadges, {
+import {
   htmlReportsToFile,
   metricsToSvg,
+  processParameters,
   processRawLighthouseResult,
 } from '../src/lighthouse-badges';
 import { zip } from '../src/util';
-import { parser } from '../src/argparser';
+import parser from '../src/argparser';
 import reportFixture from '../assets/report/emanuelemazzotta.com.json';
 
 describe('test lighthouse badges', () => {
@@ -14,7 +14,7 @@ describe('test lighthouse badges', () => {
     it('should return correct metrics and no report', async () => {
       const url = 'https://emanuelemazzotta.com';
       const shouldSaveReport = false;
-      const result = await processRawLighthouseResult(reportFixture, url, shouldSaveReport);
+      const result = await processRawLighthouseResult(reportFixture, '', url, shouldSaveReport);
       expect({
         metrics: {
           'lighthouse performance': 98,
@@ -30,10 +30,15 @@ describe('test lighthouse badges', () => {
     });
 
     it('should return correct metrics and a valid report', async () => {
-      const expectedHtmlReport = ReportGenerator.generateReportHtml(reportFixture);
+      const expectedHtmlReport = '<html>Fake report</html>';
       const url = 'https://emanuelemazzotta.com';
       const shouldSaveReport = true;
-      const result = await processRawLighthouseResult(reportFixture, url, shouldSaveReport);
+      const result = await processRawLighthouseResult(
+        reportFixture,
+        expectedHtmlReport,
+        url,
+        shouldSaveReport,
+      );
       expect({
         metrics: {
           'lighthouse performance': 98,
@@ -142,8 +147,8 @@ describe('test lighthouse badges', () => {
       ]);
 
       const calculateLighthouseMetrics = jest.fn();
-      calculateLighthouseMetrics.mockReturnValue(await processRawLighthouseResult(reportFixture, 'https://example.org', args.save_report));
-      await lighthouseBadges.processParameters(args, calculateLighthouseMetrics);
+      calculateLighthouseMetrics.mockReturnValue(await processRawLighthouseResult(reportFixture, '<html>Fake report</html>', 'https://example.org', args.save_report));
+      await processParameters(args, calculateLighthouseMetrics);
 
       expect(output.length).toBe(2);
     });
@@ -155,8 +160,8 @@ describe('test lighthouse badges', () => {
       ]);
 
       const calculateLighthouseMetrics = jest.fn();
-      calculateLighthouseMetrics.mockReturnValue(await processRawLighthouseResult(reportFixture, 'https://example.org', args.save_report));
-      await lighthouseBadges.processParameters(args, calculateLighthouseMetrics);
+      calculateLighthouseMetrics.mockReturnValue(await processRawLighthouseResult(reportFixture, '<html>Fake report</html>', 'https://example.org', args.save_report));
+      await processParameters(args, calculateLighthouseMetrics);
 
       expect(output.length).toBe(6);
     });
@@ -168,8 +173,8 @@ describe('test lighthouse badges', () => {
       ]);
 
       const calculateLighthouseMetrics = jest.fn();
-      calculateLighthouseMetrics.mockReturnValue(await processRawLighthouseResult(reportFixture, 'https://example.org', args.save_report));
-      await lighthouseBadges.processParameters(args, calculateLighthouseMetrics);
+      calculateLighthouseMetrics.mockReturnValue(await processRawLighthouseResult(reportFixture, null, 'https://example.org', args.save_report));
+      await processParameters(args, calculateLighthouseMetrics);
 
       expect(output.length).toBe(1);
     });
@@ -180,8 +185,8 @@ describe('test lighthouse badges', () => {
       ]);
 
       const calculateLighthouseMetrics = jest.fn();
-      calculateLighthouseMetrics.mockReturnValue(await processRawLighthouseResult(reportFixture, 'https://example.org', args.save_report));
-      await lighthouseBadges.processParameters(args, calculateLighthouseMetrics);
+      calculateLighthouseMetrics.mockReturnValue(await processRawLighthouseResult(reportFixture, null, 'https://example.org', args.save_report));
+      await processParameters(args, calculateLighthouseMetrics);
 
       expect(output.length).toBe(5);
     });

package/dist/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Emanuele Mazzotta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/README.md

@@ -0,0 +1,103 @@
+[![Build Status](https://github.com/emazzotta/lighthouse-badges/workflows/build/badge.svg)](https://github.com/emazzotta/lighthouse-badges/actions)
+[![Code Coverage](https://codecov.io/gh/emazzotta/lighthouse-badges/branch/master/graph/badge.svg)](https://github.com/emazzotta/lighthouse-badges/actions)
+[![NPM downloads](https://img.shields.io/npm/dt/lighthouse-badges?color=blue)](https://www.npmjs.org/package/lighthouse-badges)
+[![NPM version](https://img.shields.io/npm/v/lighthouse-badges.svg)](https://www.npmjs.org/package/lighthouse-badges)
+[![License](http://img.shields.io/:license-mit-blue.svg?style=flat)](https://emanuelemazzotta.com/mit-license) 
+
+# Lighthouse Badges
+
+[![Lighthouse](./assets/img/lighthouse.svg)](https://github.com/GoogleChrome/lighthouse)
+
+This package allows you to easily create Lighthouse badges for all Lighthouse categories.  
+Ever wanted to brag about your sites's awesome Lighthouse performance? Then this is the package for you!  
+
+## Examples
+
+### All Badges
+
+[![Lighthouse Accessibility Badge](./assets/img/scores/lighthouse_accessibility.svg)](https://github.com/emazzotta/lighthouse-badges)
+[![Lighthouse Best Practices Badge](./assets/img/scores/lighthouse_best-practices.svg)](https://github.com/emazzotta/lighthouse-badges)
+[![Lighthouse Performance Badge](./assets/img/scores/lighthouse_performance.svg)](https://github.com/emazzotta/lighthouse-badges)
+[![Lighthouse PWA Badge](./assets/img/scores/lighthouse_pwa.svg)](https://github.com/emazzotta/lighthouse-badges)
+[![Lighthouse SEO Badge](./assets/img/scores/lighthouse_seo.svg)](https://github.com/emazzotta/lighthouse-badges)
+
+### Single Badge
+
+[![Lighthouse](./assets/img/scores/lighthouse.svg)](https://github.com/emazzotta/lighthouse-badges)
+
+## Usage
+
+### Help
+
+```txt
+usage: lighthouse-badges [-h] [-v] [-s]
+                         [-b {flat,flat-square,plastic,for-the-badge,popout,popout-square,social}]
+                         [-o OUTPUT_PATH] [-r] -u URLS [URLS ...]
+
+
+Generate gh-badges (shields.io) based on lighthouse performance.
+
+Optional arguments:
+  -h, --help            Show this help message and exit.
+  -v, --version         Show program's version number and exit.
+  -s, --single-badge    Output only one single badge averaging all lighthouse
+                        categories' scores
+  -b {flat,flat-square,plastic,for-the-badge,popout,popout-square,social}, --badge-style {flat,flat-square,plastic,for-the-badge,popout,popout-square,social}
+                        Define look and feel for the badge
+  -o OUTPUT_PATH, --output-path OUTPUT_PATH
+                        Define output path for artifacts
+  -r, --save-report     Save lighthouse report as html for every supplied url
+
+Required arguments:
+  -u URLS [URLS ...], --urls URLS [URLS ...]
+                        The lighthouse badge(s) will contain the respective
+                        average score(s) of all the urls supplied, combined
+```
+
+Additionally, you can pass parameters to the lighthouse process directly via environment variable:
+
+```bash
+# This will pass '--preset=desktop' to the lighthouse process
+export LIGHTHOUSE_BADGES_PARAMS="--preset=desktop"
+lighthouse-badges --urls https://www.youtube.com/
+```
+
+### Run
+
+Hint: Only node >= 12 is supported.
+
+#### Option 1: npm
+```bash
+npm i -g lighthouse-badges
+lighthouse-badges --urls https://www.youtube.com/ https://www.youtube.com/feed/trending -o test_results
+```
+
+#### Option 2: npx
+```bash
+npx lighthouse-badges --urls https://www.youtube.com/ https://www.youtube.com/feed/trending -o test_results
+```
+
+#### Option 3: Docker
+```bash
+# Warning, the docker version may alter the lighthouse results
+docker run --rm \
+    -v $PWD/test_results:/home/chrome/reports \
+    emazzotta/lighthouse-badges \
+    /bin/sh -c "lighthouse-badges --urls https://www.youtube.com/ https://www.youtube.com/feed/trending"
+```
+
+## Contributing
+
+See [contribution guideline](./CONTRIBUTING.md)
+
+## Sponsors
+
+Sponsored by [JetBrains](https://www.jetbrains.com/?from=Lighthouse-Badges)
+
+<a href="https://www.jetbrains.com/?from=Lighthouse-Badges">
+  <img alt="Jetbrains Logo" src="./assets/img/jetbrains.svg" height="100">
+</a>
+
+## Author
+
+[Emanuele Mazzotta](mailto:hello@mazzotta.me)

package/dist/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "lighthouse-badges",
+  "version": "1.2.0",
+  "description": "🚦Generate gh-badges (shields.io) based on Lighthouse performance.",
+  "main": "src/index.js",
+  "bin": {
+    "lighthouse-badges": "src/index.js"
+  },
+  "scripts": {
+    "app:install": "npm i -g .",
+    "app:reinstall": "npm-run-all app:uninstall app:install",
+    "app:uninstall": "npm uninstall -g @emazzotta/lighthouse-badges",
+    "build": "npm run clean && babel src --out-dir dist/src && sed 's#\"dist/src/index.js\"#\"src/index.js\"#' package.json > ./dist/package.json && cp README.md dist && cp LICENSE.md dist",
+    "ci:publish": "npm run build && npm publish --prefix dist",
+    "clean": "rm -rf *.svg *.html coverage dist results",
+    "docker:build": "npm run build && docker build --build-arg VCS_REF=`git rev-parse --short HEAD` --build-arg BUILD_DATE=`date -u +\"%Y-%m-%dT%H:%M:%SZ\"` --build-arg VERSION=latest -t emazzotta/lighthouse-badges .",
+    "docker:system-test:run": "docker run emazzotta/lighthouse-badges /bin/sh -c 'lighthouse-badges -rsu https://google.com && EXEC_PATH=/home/chrome/reports npm run system-test:verify --prefix /home/lighthouse'",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "pre-push": "npm-run-all lint:fix test:all",
+    "run:global-installation": "[ -z ${PAGE} ] && PAGE=https://google.com ; lighthouse-badges -rsu ${PAGE} -o results",
+    "run:local-installation": "[ -z ${PAGE} ] && PAGE=https://google.com ; node dist/src/index.js -rsu ${PAGE} -o results",
+    "system-test:full-run": "npm-run-all clean build app:reinstall run:global-installation system-test:verify",
+    "system-test:light-run": "npm-run-all clean build run:local-installation system-test:verify",
+    "system-test:verify": "[ -z ${EXEC_PATH} ] && EXEC_PATH=$PWD/results ; grep -q '<svg xmlns' ${EXEC_PATH}/*.svg && grep -q '<title>Lighthouse Report</title>' ${EXEC_PATH}/*.html",
+    "test": "jest",
+    "test:all": "npm-run-all test system-test:full-run",
+    "test:related": "jest --findRelatedTests"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.js": [
+      "npm run lint:fix",
+      "npm run test:related"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/emazzotta/lighthouse-badges.git"
+  },
+  "dependencies": {
+    "argparse": "2.0.1",
+    "badge-maker": "^3.3.1",
+    "chrome-launcher": "^0.15.1",
+    "clui": "^0.3.6",
+    "lighthouse": "^10.0.0",
+    "ramda": "^0.28.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.20.7",
+    "@babel/core": "^7.20.12",
+    "@babel/plugin-transform-runtime": "^7.19.6",
+    "@babel/preset-env": "^7.20.2",
+    "@types/jest": "^29.4.0",
+    "eslint": "^8.33.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-plugin-import": "^2.27.5",
+    "husky": "^8.0.3",
+    "jest": "^29.4.2",
+    "lint-staged": "^13.1.1",
+    "npm-run-all": "^4.1.5"
+  },
+  "engines": {
+    "npm": ">=7.0.0",
+    "node": ">=16.0.0"
+  },
+  "packageManager": "yarn@1.21.1",
+  "private": false,
+  "author": "Emanuele Mazzotta",
+  "license": "MIT"
+}

package/dist/src/argparser.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _argparse = require("argparse");
+var _package = require("../package.json");
+var parser = new _argparse.ArgumentParser({
+  add_help: true,
+  description: 'Generate gh-badges (shields.io) based on lighthouse performance.'
+});
+var requiredArgs = parser.add_argument_group({
+  title: 'Required arguments'
+});
+parser.add_argument('-v', '--version', {
+  action: 'version',
+  version: _package.version
+});
+parser.add_argument('-s', '--single-badge', {
+  action: 'store_true',
+  required: false,
+  help: 'Output only one single badge averaging all lighthouse categories\' scores '
+});
+parser.add_argument('-b', '--badge-style', {
+  action: 'store',
+  required: false,
+  choices: ['flat', 'flat-square', 'plastic', 'for-the-badge', 'popout', 'popout-square', 'social'],
+  "default": 'flat',
+  help: 'Define look and feel for the badge'
+});
+parser.add_argument('-o', '--output-path', {
+  action: 'store',
+  required: false,
+  help: 'Define output path for artifacts'
+});
+parser.add_argument('-r', '--save-report', {
+  action: 'store_true',
+  required: false,
+  help: 'Save lighthouse report as html for every supplied url'
+});
+requiredArgs.add_argument('-u', '--urls', {
+  action: 'store',
+  required: true,
+  nargs: _argparse.ONE_OR_MORE,
+  help: 'The lighthouse badge(s) will contain the respective average score(s) of all the urls supplied, combined'
+});
+var _default = parser;
+exports["default"] = _default;

package/dist/src/calculations.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.percentageToColor = exports.getSquashedScore = exports.getAverageScore = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var R = _interopRequireWildcard(require("ramda"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var percentageToColor = function percentageToColor(percentage) {
+  if (percentage >= 95) return 'brightgreen';
+  if (percentage >= 90) return 'green';
+  if (percentage >= 75) return 'yellowgreen';
+  if (percentage >= 60) return 'yellow';
+  if (percentage >= 40) return 'orange';
+  return 'red';
+};
+exports.percentageToColor = percentageToColor;
+var getAverageScore = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(metrics) {
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          return _context.abrupt("return", R.pipe(R.head, R.keys, R.map(function (category) {
+            return (0, _defineProperty2["default"])({}, category, Math.round(R.sum(R.pluck(category, metrics)) / R.length(metrics)));
+          }), R.mergeAll)(metrics));
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function getAverageScore(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+exports.getAverageScore = getAverageScore;
+var getSquashedScore = /*#__PURE__*/function () {
+  var _ref3 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(metrics) {
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          return _context2.abrupt("return", {
+            lighthouse: R.pipe(R.map(function (metric) {
+              return R.sum(R.values(metric));
+            }), R.sum, function (x) {
+              return x / (R.length(metrics) * R.length(R.keys(R.head(metrics))));
+            }, R.curry(Math.round))(metrics)
+          });
+        case 1:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return function getSquashedScore(_x2) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+exports.getSquashedScore = getSquashedScore;

package/dist/src/index.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _clui = _interopRequireDefault(require("clui"));
+var _lighthouseBadges = require("./lighthouse-badges");
+var _argparser = _interopRequireDefault(require("./argparser"));
+var handleUserInput = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(spinner) {
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.prev = 0;
+          if (process.env.LIGHTHOUSE_BADGES_PARAMS) {
+            process.stdout.write("LIGHTHOUSE_BADGES_PARAMS: ".concat(process.env.LIGHTHOUSE_BADGES_PARAMS, "\n"));
+          }
+          spinner.start();
+          _context.t0 = _lighthouseBadges.processParameters;
+          _context.next = 6;
+          return _argparser["default"].parse_args();
+        case 6:
+          _context.t1 = _context.sent;
+          _context.t2 = _lighthouseBadges.calculateLighthouseMetrics;
+          _context.next = 10;
+          return (0, _context.t0)(_context.t1, _context.t2);
+        case 10:
+          spinner.stop();
+          _context.next = 17;
+          break;
+        case 13:
+          _context.prev = 13;
+          _context.t3 = _context["catch"](0);
+          process.stderr.write("".concat(_context.t3, "\n"));
+          process.exit(1);
+        case 17:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[0, 13]]);
+  }));
+  return function handleUserInput(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+// Only self-invoke if not imported but called directly as executable
+(function () {
+  return !module.parent && handleUserInput(new _clui["default"].Spinner('Running Lighthouse, please wait...', ['◜', '◠', '◝', '◞', '◡', '◟']));
+})();
+var _default = handleUserInput;
+exports["default"] = _default;

package/dist/src/lighthouse-badges.js

@@ -0,0 +1,229 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.processRawLighthouseResult = exports.processParameters = exports.metricsToSvg = exports.htmlReportsToFile = exports.calculateLighthouseMetrics = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _badgeMaker = require("badge-maker");
+var _path = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("fs"));
+var R = _interopRequireWildcard(require("ramda"));
+var chromeLauncher = _interopRequireWildcard(require("chrome-launcher"));
+var _index = _interopRequireDefault(require("lighthouse/core/index.cjs"));
+var _util = require("./util");
+var _calculations = require("./calculations");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var metricsToSvg = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(lighthouseMetrics, badgeStyle, outputPath) {
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          R.keys(lighthouseMetrics).map(function (lighthouseMetricKey) {
+            var filepath = _path["default"].join(outputPath, "".concat(lighthouseMetricKey.replace(/ /g, '_'), ".svg"));
+            var badgeColor = (0, _calculations.percentageToColor)(lighthouseMetrics[lighthouseMetricKey]);
+            var svg = (0, _badgeMaker.makeBadge)({
+              label: lighthouseMetricKey,
+              message: "".concat(lighthouseMetrics[lighthouseMetricKey], "%"),
+              color: badgeColor,
+              style: badgeStyle
+            });
+            _fs["default"].writeFile(filepath, svg, function (error) {
+              return (0, _util.statusMessage)("Saved svg to ".concat(filepath, "\n"), "Failed to save svg to ".concat(outputPath), error);
+            });
+            return true;
+          });
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function metricsToSvg(_x, _x2, _x3) {
+    return _ref.apply(this, arguments);
+  };
+}();
+exports.metricsToSvg = metricsToSvg;
+var htmlReportsToFile = /*#__PURE__*/function () {
+  var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(htmlReports, outputPath) {
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          return _context2.abrupt("return", htmlReports.map(function (report) {
+            var url = R.head(R.keys(report));
+            if (report[url]) {
+              var filepath = _path["default"].join(outputPath, "".concat((0, _util.urlEscaper)(url), ".html"));
+              _fs["default"].writeFile(filepath, report[url], function (error) {
+                return (0, _util.statusMessage)("Saved report to ".concat(filepath, "\n"), "Failed to save report to ".concat(outputPath), error);
+              });
+            }
+            return false;
+          }));
+        case 1:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return function htmlReportsToFile(_x4, _x5) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+exports.htmlReportsToFile = htmlReportsToFile;
+var generateArtifacts = /*#__PURE__*/function () {
+  var _ref4 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(_ref3) {
+    var reports, svg, outputPath;
+    return _regenerator["default"].wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          reports = _ref3.reports, svg = _ref3.svg, outputPath = _ref3.outputPath;
+          _context3.next = 3;
+          return Promise.all([htmlReportsToFile(reports, outputPath), metricsToSvg(svg.results, svg.style, outputPath)]);
+        case 3:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return function generateArtifacts(_x6) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+var processRawLighthouseResult = /*#__PURE__*/function () {
+  var _ref5 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(data, html, url, shouldSaveReport) {
+    var htmlReport, categories, scores, lighthouseMetrics;
+    return _regenerator["default"].wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          htmlReport = shouldSaveReport ? html : false;
+          categories = data.categories;
+          scores = R.keys(categories).map(function (category) {
+            return (0, _defineProperty2["default"])({}, "lighthouse ".concat(category.toLowerCase()), categories[category].score * 100);
+          });
+          lighthouseMetrics = Object.assign.apply(Object, [{}].concat((0, _toConsumableArray2["default"])(scores)));
+          return _context4.abrupt("return", {
+            metrics: lighthouseMetrics,
+            report: (0, _defineProperty2["default"])({}, url, htmlReport)
+          });
+        case 5:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return function processRawLighthouseResult(_x7, _x8, _x9, _x10) {
+    return _ref5.apply(this, arguments);
+  };
+}();
+exports.processRawLighthouseResult = processRawLighthouseResult;
+var calculateLighthouseMetrics = /*#__PURE__*/function () {
+  var _ref7 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5(url, shouldSaveReport) {
+    var additionalParams,
+      chromeParameters,
+      chrome,
+      options,
+      runnerResult,
+      reportHtml,
+      reportJson,
+      _args5 = arguments;
+    return _regenerator["default"].wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          additionalParams = _args5.length > 2 && _args5[2] !== undefined ? _args5[2] : '';
+          chromeParameters = ['--headless', '--no-sandbox', '--disable-gpu', '--disable-dev-shm-usage', '--no-default-browser-check', '--no-first-run', '--disable-default-apps', '--output=json', '--output-path=stdout', '--quiet', additionalParams];
+          _context5.next = 4;
+          return chromeLauncher.launch({
+            chromeFlags: chromeParameters
+          });
+        case 4:
+          chrome = _context5.sent;
+          options = {
+            logLevel: 'silent',
+            output: 'html',
+            port: chrome.port
+          };
+          _context5.next = 8;
+          return (0, _index["default"])(url, options);
+        case 8:
+          runnerResult = _context5.sent;
+          reportHtml = runnerResult.report;
+          reportJson = runnerResult.lhr;
+          _context5.next = 13;
+          return chrome.kill();
+        case 13:
+          return _context5.abrupt("return", processRawLighthouseResult(reportJson, reportHtml, url, shouldSaveReport));
+        case 14:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  }));
+  return function calculateLighthouseMetrics(_x11, _x12) {
+    return _ref7.apply(this, arguments);
+  };
+}();
+exports.calculateLighthouseMetrics = calculateLighthouseMetrics;
+var processParameters = /*#__PURE__*/function () {
+  var _ref8 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6(args, func) {
+    var outputPath, additionalParams, results, metrics, reports, metricsResults;
+    return _regenerator["default"].wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          outputPath = args.output_path || process.cwd();
+          _fs["default"].mkdir(outputPath, {
+            recursive: true
+          }, function (err) {
+            if (err) throw err;
+          });
+          additionalParams = process.env.LIGHTHOUSE_BADGES_PARAMS || '';
+          _context6.next = 5;
+          return Promise.all(args.urls.map(function (url) {
+            return func(url, args.save_report, additionalParams);
+          }));
+        case 5:
+          results = _context6.sent;
+          metrics = R.pluck('metrics', results);
+          reports = R.pluck('report', results);
+          if (!args.single_badge) {
+            _context6.next = 14;
+            break;
+          }
+          _context6.next = 11;
+          return (0, _calculations.getSquashedScore)(metrics);
+        case 11:
+          _context6.t0 = _context6.sent;
+          _context6.next = 17;
+          break;
+        case 14:
+          _context6.next = 16;
+          return (0, _calculations.getAverageScore)(metrics);
+        case 16:
+          _context6.t0 = _context6.sent;
+        case 17:
+          metricsResults = _context6.t0;
+          _context6.next = 20;
+          return generateArtifacts({
+            reports: reports,
+            svg: {
+              results: metricsResults,
+              style: args.badge_style
+            },
+            outputPath: outputPath
+          });
+        case 20:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  }));
+  return function processParameters(_x13, _x14) {
+    return _ref8.apply(this, arguments);
+  };
+}();
+exports.processParameters = processParameters;

package/dist/src/util.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.zip = exports.urlEscaper = exports.statusMessage = void 0;
+var urlEscaper = function urlEscaper(url) {
+  return url.toLowerCase().replace(/(^\w+:|^)\/\//, '').replace(/[^a-z0-9]/g, '_');
+};
+exports.urlEscaper = urlEscaper;
+var zip = function zip(rows) {
+  return rows[0].map(function (_, c) {
+    return rows.map(function (row) {
+      return row[c];
+    });
+  });
+};
+exports.zip = zip;
+var statusMessage = function statusMessage(successMessage, errorMessage, error) {
+  if (error) {
+    throw new Error(errorMessage);
+  }
+  process.stdout.write(successMessage);
+};
+exports.statusMessage = statusMessage;

package/jest.config.js

@@ -0,0 +1,16 @@
+module.exports = async () => ({
+  collectCoverageFrom: [
+    'src/**/*.{js,jsx,mjs}',
+  ],
+  collectCoverage: true,
+  coverageReporters: [
+    'json',
+    'html',
+  ],
+  transform: {
+    '^.+\\.(js|jsx)$': 'babel-jest',
+  },
+  transformIgnorePatterns: [
+    '/node_modules/(?!lighthouse)',
+  ],
+});

package/package.json

@@ -1,26 +1,30 @@
 {
   "name": "lighthouse-badges",
-  "version": "1.1.26",
+  "version": "1.2.0",
   "description": "🚦Generate gh-badges (shields.io) based on Lighthouse performance.",
-  "main": "src/index.js",
+  "main": "dist/src/index.js",
   "bin": {
-    "lighthouse-badges": "src/index.js"
+    "lighthouse-badges": "dist/src/index.js"
   },
   "scripts": {
-    "clean": "rm -f *.svg *.html",
-    "docker:build": "docker build --build-arg VCS_REF=`git rev-parse --short HEAD` --build-arg BUILD_DATE=`date -u +\"%Y-%m-%dT%H:%M:%SZ\"` --build-arg VERSION=latest -t emazzotta/lighthouse-badges .",
+    "app:install": "npm i -g .",
+    "app:reinstall": "npm-run-all app:uninstall app:install",
+    "app:uninstall": "npm uninstall -g @emazzotta/lighthouse-badges",
+    "build": "npm run clean && babel src --out-dir dist/src && sed 's#\"dist/src/index.js\"#\"src/index.js\"#' package.json > ./dist/package.json && cp README.md dist && cp LICENSE.md dist",
+    "ci:publish": "npm run build && npm publish --prefix dist",
+    "clean": "rm -rf *.svg *.html coverage dist results",
+    "docker:build": "npm run build && docker build --build-arg VCS_REF=`git rev-parse --short HEAD` --build-arg BUILD_DATE=`date -u +\"%Y-%m-%dT%H:%M:%SZ\"` --build-arg VERSION=latest -t emazzotta/lighthouse-badges .",
     "docker:system-test:run": "docker run emazzotta/lighthouse-badges /bin/sh -c 'lighthouse-badges -rsu https://google.com && EXEC_PATH=/home/chrome/reports npm run system-test:verify --prefix /home/lighthouse'",
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
-    "pre-push": "npm-run-all lint:fix test system-test:full-run",
-    "reinstall": "npm uninstall -g . && npm i -g .",
-    "run:global-installation": "[ -z ${PAGE} ] && PAGE=https://google.com ; lighthouse-badges -rsu ${PAGE}",
-    "run:local-installation": "[ -z ${PAGE} ] && PAGE=https://google.com ; node ./src/index.js -rsu ${PAGE}",
-    "system-test:full-run": "npm-run-all clean reinstall run:global-installation system-test:verify clean",
-    "system-test:light-run": "npm-run-all clean run:local-installation system-test:verify clean",
-    "system-test:start-server": "npx http-server -a 127.0.0.1 -p 8080 &",
-    "system-test:verify": "[ -z ${EXEC_PATH} ] && EXEC_PATH=$PWD ; grep -q '<svg xmlns' ${EXEC_PATH}/*.svg && grep -q '<title>Lighthouse Report</title>' ${EXEC_PATH}/*.html",
+    "pre-push": "npm-run-all lint:fix test:all",
+    "run:global-installation": "[ -z ${PAGE} ] && PAGE=https://google.com ; lighthouse-badges -rsu ${PAGE} -o results",
+    "run:local-installation": "[ -z ${PAGE} ] && PAGE=https://google.com ; node dist/src/index.js -rsu ${PAGE} -o results",
+    "system-test:full-run": "npm-run-all clean build app:reinstall run:global-installation system-test:verify",
+    "system-test:light-run": "npm-run-all clean build run:local-installation system-test:verify",
+    "system-test:verify": "[ -z ${EXEC_PATH} ] && EXEC_PATH=$PWD/results ; grep -q '<svg xmlns' ${EXEC_PATH}/*.svg && grep -q '<title>Lighthouse Report</title>' ${EXEC_PATH}/*.html",
     "test": "jest",
+    "test:all": "npm-run-all test system-test:full-run",
     "test:related": "jest --findRelatedTests"
   },
   "husky": {
@@ -41,34 +45,31 @@
   "dependencies": {
     "argparse": "2.0.1",
     "badge-maker": "^3.3.1",
+    "chrome-launcher": "^0.15.1",
     "clui": "^0.3.6",
-    "lighthouse": "^9.6.6",
+    "lighthouse": "^10.0.0",
     "ramda": "^0.28.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.18.10",
-    "@babel/plugin-transform-runtime": "^7.18.10",
-    "@babel/preset-env": "^7.18.10",
-    "@babel/runtime": "^7.18.9",
-    "babel-jest": "^28.1.3",
-    "eslint": "^8.22.0",
+    "@babel/cli": "^7.20.7",
+    "@babel/core": "^7.20.12",
+    "@babel/plugin-transform-runtime": "^7.19.6",
+    "@babel/preset-env": "^7.20.2",
+    "@types/jest": "^29.4.0",
+    "eslint": "^8.33.0",
     "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-plugin-import": "^2.26.0",
-    "husky": "^8.0.1",
-    "jest": "^28.1.3",
-    "lint-staged": "^13.0.3",
+    "eslint-plugin-import": "^2.27.5",
+    "husky": "^8.0.3",
+    "jest": "^29.4.2",
+    "lint-staged": "^13.1.1",
     "npm-run-all": "^4.1.5"
   },
-  "jest": {
-    "collectCoverageFrom": [
-      "src/**/*.{js,jsx,mjs}"
-    ],
-    "collectCoverage": true,
-    "coverageReporters": [
-      "json",
-      "html"
-    ]
+  "engines": {
+    "npm": ">=7.0.0",
+    "node": ">=16.0.0"
   },
+  "packageManager": "yarn@1.21.1",
+  "private": false,
   "author": "Emanuele Mazzotta",
   "license": "MIT"
 }

package/src/argparser.js

@@ -1,5 +1,5 @@
-const { ArgumentParser, ONE_OR_MORE } = require('argparse');
-const { version } = require('../package.json');
+import { ArgumentParser, ONE_OR_MORE } from 'argparse';
+import { version } from '../package.json';
 
 const parser = new ArgumentParser({
   add_help: true,
@@ -46,6 +46,4 @@ requiredArgs.add_argument('-u', '--urls', {
   help: 'The lighthouse badge(s) will contain the respective average score(s) of all the urls supplied, combined',
 });
 
-module.exports = {
-  parser,
-};
+export default parser;

package/src/calculations.js

@@ -1,6 +1,6 @@
-const R = require('ramda');
+import * as R from 'ramda';
 
-const percentageToColor = (percentage) => {
+export const percentageToColor = (percentage) => {
   if (percentage >= 95) return 'brightgreen';
   if (percentage >= 90) return 'green';
   if (percentage >= 75) return 'yellowgreen';
@@ -9,7 +9,7 @@ const percentageToColor = (percentage) => {
   return 'red';
 };
 
-const getAverageScore = async (metrics) => R.pipe(
+export const getAverageScore = async (metrics) => R.pipe(
   R.head,
   R.keys,
   R.map((category) => (
@@ -17,7 +17,7 @@ const getAverageScore = async (metrics) => R.pipe(
   R.mergeAll,
 )(metrics);
 
-const getSquashedScore = async (metrics) => ({
+export const getSquashedScore = async (metrics) => ({
   lighthouse: R.pipe(
     R.map((metric) => R.sum(R.values(metric))),
     R.sum,
@@ -25,9 +25,3 @@ const getSquashedScore = async (metrics) => ({
     R.curry(Math.round),
   )(metrics),
 });
-
-module.exports = {
-  percentageToColor,
-  getAverageScore,
-  getSquashedScore,
-};

package/src/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
-const CLI = require('clui');
-const { processParameters, calculateLighthouseMetrics } = require('./lighthouse-badges');
-const { parser } = require('./argparser');
+import CLI from 'clui';
+import { calculateLighthouseMetrics, processParameters } from './lighthouse-badges';
+import parser from './argparser';
 
 const handleUserInput = async (spinner) => {
   try {
@@ -21,6 +21,4 @@ const handleUserInput = async (spinner) => {
 // Only self-invoke if not imported but called directly as executable
 (() => !module.parent && handleUserInput(new CLI.Spinner('Running Lighthouse, please wait...', ['◜', '◠', '◝', '◞', '◡', '◟'])))();
 
-module.exports = {
-  handleUserInput,
-};
+export default handleUserInput;

package/src/lighthouse-badges.js

@@ -1,19 +1,13 @@
-const { makeBadge } = require('badge-maker');
-const path = require('path');
-const fs = require('fs');
-const ReportGenerator = require('lighthouse/report/generator/report-generator');
-const { promisify } = require('util');
-const { exec } = require('child_process');
-const R = require('ramda');
-const { statusMessage } = require('./util');
-const { getAverageScore, getSquashedScore } = require('./calculations');
-const { urlEscaper } = require('./util');
-const { percentageToColor } = require('./calculations');
-
-// Buffer size for stdout, must be big enough to handle lighthouse CLI output
-const maxBuffer = 1024 * 50000;
-
-const metricsToSvg = async (lighthouseMetrics, badgeStyle, outputPath) => {
+import { makeBadge } from 'badge-maker';
+import path from 'path';
+import fs from 'fs';
+import * as R from 'ramda';
+import * as chromeLauncher from 'chrome-launcher';
+import lighthouse from 'lighthouse/core/index.cjs';
+import { statusMessage, urlEscaper } from './util';
+import { getAverageScore, getSquashedScore, percentageToColor } from './calculations';
+
+export const metricsToSvg = async (lighthouseMetrics, badgeStyle, outputPath) => {
   R.keys(lighthouseMetrics).map((lighthouseMetricKey) => {
     const filepath = path.join(outputPath, `${lighthouseMetricKey.replace(/ /g, '_')}.svg`);
     const badgeColor = percentageToColor(lighthouseMetrics[lighthouseMetricKey]);
@@ -35,11 +29,11 @@ const metricsToSvg = async (lighthouseMetrics, badgeStyle, outputPath) => {
   });
 };
 
-const htmlReportsToFile = async (htmlReports, outputPath) => htmlReports.map((htmlReport) => {
-  const url = R.head(R.keys(htmlReport));
-  if (htmlReport[url]) {
+export const htmlReportsToFile = async (htmlReports, outputPath) => htmlReports.map((report) => {
+  const url = R.head(R.keys(report));
+  if (report[url]) {
     const filepath = path.join(outputPath, `${urlEscaper(url)}.html`);
-    fs.writeFile(filepath, htmlReport[url], (error) => statusMessage(
+    fs.writeFile(filepath, report[url], (error) => statusMessage(
       `Saved report to ${filepath}\n`,
       `Failed to save report to ${outputPath}`,
       error,
@@ -55,8 +49,8 @@ const generateArtifacts = async ({ reports, svg, outputPath }) => {
   ]);
 };
 
-const processRawLighthouseResult = async (data, url, shouldSaveReport) => {
-  const htmlReport = shouldSaveReport ? ReportGenerator.generateReportHtml(data) : false;
+export const processRawLighthouseResult = async (data, html, url, shouldSaveReport) => {
+  const htmlReport = shouldSaveReport ? html : false;
   const { categories } = data;
   const scores = R.keys(categories).map((category) => (
     { [`lighthouse ${category.toLowerCase()}`]: categories[category].score * 100 }
@@ -65,16 +59,31 @@ const processRawLighthouseResult = async (data, url, shouldSaveReport) => {
   return { metrics: lighthouseMetrics, report: { [url]: htmlReport } };
 };
 
-const calculateLighthouseMetrics = async (url, shouldSaveReport, additionalParams = '') => {
-  const lighthouseBinary = path.join(__dirname, '..', 'node_modules', '.bin', 'lighthouse');
-  const params = `--chrome-flags='--headless --no-sandbox --disable-gpu --disable-dev-shm-usage --no-default-browser-check --no-first-run --disable-default-apps' --output=json --output-path=stdout --quiet ${additionalParams}`;
-  const lighthouseCommand = `${lighthouseBinary} ${params} ${url}`;
-  const execPromise = promisify(exec);
-  const { stdout } = await execPromise(`${lighthouseCommand}`, { maxBuffer });
-  return processRawLighthouseResult(JSON.parse(stdout), url, shouldSaveReport);
+export const calculateLighthouseMetrics = async (url, shouldSaveReport, additionalParams = '') => {
+  const chromeParameters = [
+    '--headless',
+    '--no-sandbox',
+    '--disable-gpu',
+    '--disable-dev-shm-usage',
+    '--no-default-browser-check',
+    '--no-first-run',
+    '--disable-default-apps',
+    '--output=json',
+    '--output-path=stdout',
+    '--quiet',
+    additionalParams,
+  ];
+  const chrome = await chromeLauncher.launch({ chromeFlags: chromeParameters });
+  const options = { logLevel: 'silent', output: 'html', port: chrome.port };
+  const runnerResult = await lighthouse(url, options);
+  const reportHtml = runnerResult.report;
+  const reportJson = runnerResult.lhr;
+  await chrome.kill();
+
+  return processRawLighthouseResult(reportJson, reportHtml, url, shouldSaveReport);
 };
 
-const processParameters = async (args, func) => {
+export const processParameters = async (args, func) => {
   const outputPath = args.output_path || process.cwd();
 
   fs.mkdir(outputPath, { recursive: true }, (err) => {
@@ -99,11 +108,3 @@ const processParameters = async (args, func) => {
     outputPath,
   });
 };
-
-module.exports = {
-  metricsToSvg,
-  htmlReportsToFile,
-  processRawLighthouseResult,
-  calculateLighthouseMetrics,
-  processParameters,
-};

package/src/util.js

@@ -1,16 +1,10 @@
-const urlEscaper = (url) => url.toLowerCase().replace(/(^\w+:|^)\/\//, '').replace(/[^a-z0-9]/g, '_');
+export const urlEscaper = (url) => url.toLowerCase().replace(/(^\w+:|^)\/\//, '').replace(/[^a-z0-9]/g, '_');
 
-const zip = (rows) => rows[0].map((_, c) => rows.map((row) => row[c]));
+export const zip = (rows) => rows[0].map((_, c) => rows.map((row) => row[c]));
 
-const statusMessage = (successMessage, errorMessage, error) => {
+export const statusMessage = (successMessage, errorMessage, error) => {
   if (error) {
     throw new Error(errorMessage);
   }
   process.stdout.write(successMessage);
 };
-
-module.exports = {
-  urlEscaper,
-  zip,
-  statusMessage,
-};