lighthouse-badges 1.3.16 → 1.4.0

package/README.md

@@ -1,5 +1,4 @@
 [![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](https://img.shields.io/:license-mit-blue.svg?style=flat)](https://emanuelemazzotta.com/mit-license)

package/__tests__/{argparser.js → argparser.ts}

@@ -25,3 +25,4 @@ describe('test argparser', () => {
     expect(actualArgs.url).toStrictEqual(baseUrl);
   });
 });
+

package/__tests__/calculations.ts

@@ -0,0 +1,105 @@
+import { getAverageScore, getSquashedScore, percentageToColor } from '../src/calculations';
+
+describe('calculations', () => {
+  describe('percentageToColor', () => {
+    it('should return brightgreen for very high number', () => {
+      expect(percentageToColor(97)).toBe('brightgreen');
+    });
+
+    it('should return green for high number', () => {
+      expect(percentageToColor(92)).toBe('green');
+    });
+
+    it('should return yellowgreen for medium high number', () => {
+      expect(percentageToColor(85)).toBe('yellowgreen');
+    });
+
+    it('should return yellow for medium number', () => {
+      expect(percentageToColor(62)).toBe('yellow');
+    });
+
+    it('should return orange for low number', () => {
+      expect(percentageToColor(45)).toBe('orange');
+    });
+
+    it('should return red for very low number', () => {
+      expect(percentageToColor(23)).toBe('red');
+    });
+  });
+
+  describe('getAverageScore', () => {
+    it('should calculate the expected average', () => {
+      const expectedResult = {
+        'lighthouse accessibility': 60,
+        'lighthouse performance': 51,
+      };
+      const input = [
+        { 'lighthouse accessibility': 100, 'lighthouse performance': 52 },
+        { 'lighthouse accessibility': 20, 'lighthouse performance': 50 },
+      ];
+      const actualResult = getAverageScore(input);
+      expect(expectedResult).toStrictEqual(actualResult);
+    });
+
+    it('should round the expected average correctly', () => {
+      const expectedResult = {
+        'lighthouse accessibility': 99,
+        'lighthouse performance': 99,
+        'lighthouse progressive web app': 99,
+        'lighthouse best practices': 99,
+      };
+      const input = [
+        {
+          'lighthouse accessibility': 100,
+          'lighthouse performance': 100,
+          'lighthouse progressive web app': 100,
+          'lighthouse best practices': 100,
+        },
+        {
+          'lighthouse accessibility': 98.9,
+          'lighthouse performance': 98.9,
+          'lighthouse progressive web app': 98.9,
+          'lighthouse best practices': 98.9,
+        },
+      ];
+      const actualResult = getAverageScore(input);
+      expect(expectedResult).toStrictEqual(actualResult);
+    });
+
+    it('should return empty object for empty input', () => {
+      const result = getAverageScore([]);
+      expect(result).toStrictEqual({});
+    });
+  });
+
+  describe('getSquashedScore', () => {
+    it('should calculate the expected squashed average', () => {
+      const expectedResult = { lighthouse: 50 };
+      const input = [
+        { 'lighthouse accessibility': 100, 'lighthouse performance': 60 },
+        { 'lighthouse accessibility': 20, 'lighthouse performance': 20 },
+      ];
+      const actualResult = getSquashedScore(input);
+      expect(expectedResult).toStrictEqual(actualResult);
+    });
+
+    it('should round the expected squashed average correctly', () => {
+      const expectedResult = { lighthouse: 83 };
+      const input = [
+        {
+          'lighthouse accessibility': 100,
+          'lighthouse performance': 100,
+          'lighthouse progressive web app': 55,
+          'lighthouse best practices': 75,
+        },
+      ];
+      const actualResult = getSquashedScore(input);
+      expect(expectedResult).toStrictEqual(actualResult);
+    });
+
+    it('should return zero score for empty input', () => {
+      const result = getSquashedScore([]);
+      expect(result).toStrictEqual({ lighthouse: 0 });
+    });
+  });
+});

package/__tests__/{lighthouse-badges.js → lighthouse-badges.ts}

@@ -1,3 +1,4 @@
+import { jest } from '@jest/globals';
 import fs from 'fs';
 import {
   htmlReportsToFile,
@@ -8,13 +9,14 @@ import {
 import { zip } from '../src/util';
 import parser from '../src/argparser';
 import reportFixture from '../assets/report/emanuelemazzotta.com.json';
+import type { LighthouseLHR, LighthouseMetrics, LighthouseReport, ProcessedLighthouseResult, LighthouseConfig } from '../src/types';
 
 describe('test lighthouse badges', () => {
   describe('the lighthouse command results are processed as expected', () => {
     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 as LighthouseLHR, '', url, shouldSaveReport);
       expect({
         metrics: {
           'lighthouse performance': 98,
@@ -34,7 +36,7 @@ describe('test lighthouse badges', () => {
       const url = 'https://emanuelemazzotta.com';
       const shouldSaveReport = true;
       const result = await processRawLighthouseResult(
-        reportFixture,
+        reportFixture as LighthouseLHR,
         expectedHtmlReport,
         url,
         shouldSaveReport,
@@ -55,13 +57,14 @@ describe('test lighthouse badges', () => {
   });
 
   describe('the html reports are saved correctly', () => {
-    let output;
+    let output: Array<Record<string, string>>;
     const { writeFile } = fs;
 
     beforeEach(() => {
       output = [];
-      fs.writeFile = (path, content) => {
-        output.push({ [path]: content });
+      (fs.writeFile as unknown) = (path: fs.PathLike, content: string | NodeJS.ArrayBufferView, callback?: (err: NodeJS.ErrnoException | null) => void) => {
+        output.push({ [path.toString()]: content.toString() });
+        if (callback) callback(null);
       };
     });
 
@@ -70,7 +73,7 @@ describe('test lighthouse badges', () => {
     });
 
     it('should save html report', async () => {
-      const htmlReports = [
+      const htmlReports: LighthouseReport[] = [
         { 'https://emanuelemazzotta.com': 'a report' },
         { 'https://emanuelemazzotta.com/cv': 'another report' },
       ];
@@ -86,20 +89,24 @@ describe('test lighthouse badges', () => {
     });
 
     it('should not save html report if toggle is false', async () => {
-      const htmlReports = [false, false];
-      await htmlReportsToFile(htmlReports);
+      const htmlReports: LighthouseReport[] = [
+        { 'https://example.com': false },
+        { 'https://example2.com': false },
+      ];
+      await htmlReportsToFile(htmlReports, process.cwd());
       expect(output.length).toBe(0);
     });
   });
 
   describe('the svg files are saved correctly', () => {
-    let output;
+    let output: Array<Record<string, string>>;
     const { writeFile } = fs;
 
     beforeEach(() => {
       output = [];
-      fs.writeFile = (path, content) => {
-        output.push({ [path]: content });
+      (fs.writeFile as unknown) = (path: fs.PathLike, content: string | NodeJS.ArrayBufferView, callback?: (err: NodeJS.ErrnoException | null) => void) => {
+        output.push({ [path.toString()]: content.toString() });
+        if (callback) callback(null);
       };
     });
 
@@ -108,7 +115,7 @@ describe('test lighthouse badges', () => {
     });
 
     it('should save all svg files', async () => {
-      const lighthouseMetrics = {
+      const lighthouseMetrics: LighthouseMetrics = {
         'lighthouse performance': 100,
         'lighthouse pwa': 85,
         'lighthouse accessibility': 100,
@@ -125,13 +132,14 @@ describe('test lighthouse badges', () => {
   });
 
   describe('test the main process function', () => {
-    let output;
+    let output: Array<Record<string, string>>;
     const { writeFile } = fs;
 
     beforeEach(() => {
       output = [];
-      fs.writeFile = (path, content) => {
-        output.push({ [path]: content });
+      (fs.writeFile as unknown) = (path: fs.PathLike, content: string | NodeJS.ArrayBufferView, callback?: (err: NodeJS.ErrnoException | null) => void) => {
+        output.push({ [path.toString()]: content.toString() });
+        if (callback) callback(null);
       };
     });
 
@@ -146,9 +154,9 @@ describe('test lighthouse badges', () => {
         '--url', 'https://example.org',
       ]);
 
-      const calculateLighthouseMetrics = jest.fn();
-      calculateLighthouseMetrics.mockReturnValue(await processRawLighthouseResult(reportFixture, '<html>Fake report</html>', 'https://example.org', args.save_report));
-      await processParameters(args, calculateLighthouseMetrics);
+      const calculateLighthouseMetrics = jest.fn<() => Promise<ProcessedLighthouseResult>>();
+      calculateLighthouseMetrics.mockResolvedValue(await processRawLighthouseResult(reportFixture as LighthouseLHR, '<html>Fake report</html>', 'https://example.org', args.save_report));
+      await processParameters(args, calculateLighthouseMetrics as (url: string, shouldSaveReport: boolean, lighthouseParameters?: LighthouseConfig) => Promise<ProcessedLighthouseResult>);
 
       expect(output.length).toBe(2);
     });
@@ -159,9 +167,9 @@ describe('test lighthouse badges', () => {
         '--url', 'https://example.org',
       ]);
 
-      const calculateLighthouseMetrics = jest.fn();
-      calculateLighthouseMetrics.mockReturnValue(await processRawLighthouseResult(reportFixture, '<html>Fake report</html>', 'https://example.org', args.save_report));
-      await processParameters(args, calculateLighthouseMetrics);
+      const calculateLighthouseMetrics = jest.fn<() => Promise<ProcessedLighthouseResult>>();
+      calculateLighthouseMetrics.mockResolvedValue(await processRawLighthouseResult(reportFixture as LighthouseLHR, '<html>Fake report</html>', 'https://example.org', args.save_report));
+      await processParameters(args, calculateLighthouseMetrics as (url: string, shouldSaveReport: boolean, lighthouseParameters?: LighthouseConfig) => Promise<ProcessedLighthouseResult>);
 
       expect(output.length).toBe(6);
     });
@@ -172,9 +180,9 @@ describe('test lighthouse badges', () => {
         '--url', 'https://example.org',
       ]);
 
-      const calculateLighthouseMetrics = jest.fn();
-      calculateLighthouseMetrics.mockReturnValue(await processRawLighthouseResult(reportFixture, null, 'https://example.org', args.save_report));
-      await processParameters(args, calculateLighthouseMetrics);
+      const calculateLighthouseMetrics = jest.fn<() => Promise<ProcessedLighthouseResult>>();
+      calculateLighthouseMetrics.mockResolvedValue(await processRawLighthouseResult(reportFixture as LighthouseLHR, '', 'https://example.org', args.save_report));
+      await processParameters(args, calculateLighthouseMetrics as (url: string, shouldSaveReport: boolean, lighthouseParameters?: LighthouseConfig) => Promise<ProcessedLighthouseResult>);
 
       expect(output.length).toBe(1);
     });
@@ -184,11 +192,12 @@ describe('test lighthouse badges', () => {
         '--url', 'https://example.org',
       ]);
 
-      const calculateLighthouseMetrics = jest.fn();
-      calculateLighthouseMetrics.mockReturnValue(await processRawLighthouseResult(reportFixture, null, 'https://example.org', args.save_report));
-      await processParameters(args, calculateLighthouseMetrics);
+      const calculateLighthouseMetrics = jest.fn<() => Promise<ProcessedLighthouseResult>>();
+      calculateLighthouseMetrics.mockResolvedValue(await processRawLighthouseResult(reportFixture as LighthouseLHR, '', 'https://example.org', args.save_report));
+      await processParameters(args, calculateLighthouseMetrics as (url: string, shouldSaveReport: boolean, lighthouseParameters?: LighthouseConfig) => Promise<ProcessedLighthouseResult>);
 
       expect(output.length).toBe(5);
     });
   });
 });
+

package/__tests__/main.ts

@@ -0,0 +1,66 @@
+import { jest } from '@jest/globals';
+import parser from '../src/argparser';
+import type { Spinner } from '../src/types';
+
+const mockProcessParameters = jest.fn<() => Promise<void>>();
+
+jest.unstable_mockModule('../src/lighthouse-badges', () => ({
+  processParameters: mockProcessParameters,
+  calculateLighthouseMetrics: jest.fn(),
+  processRawLighthouseResult: jest.fn(),
+  metricsToSvg: jest.fn(),
+  htmlReportsToFile: jest.fn(),
+}));
+
+const handleUserInput = (await import('../src/main.js')).default;
+
+describe('test index', () => {
+  let stderrOutput = '';
+  let parseMock: ReturnType<typeof jest.spyOn>;
+  const spinnerFake: Spinner = { start: () => null, stop: () => null };
+  const stderrWrite = process.stderr.write;
+  const processExit = process.exit;
+
+  beforeEach(() => {
+    parseMock = jest.spyOn(parser, 'parse_args');
+    process.stderr.write = (x: string | Uint8Array) => {
+      stderrOutput += `${x}\n`;
+      return true;
+    };
+    process.exit = (() => {
+      // Mock exit
+    }) as typeof process.exit;
+    stderrOutput = '';
+  });
+
+  afterEach(() => {
+    process.stderr.write = stderrWrite;
+    process.exit = processExit;
+    parseMock.mockRestore();
+  });
+
+  it('should invoke parse args and process parameters', async () => {
+    parseMock.mockReturnValue({ url: 'https://example.org', single_badge: false, badge_style: 'flat', save_report: false } as never);
+    mockProcessParameters.mockResolvedValue(undefined);
+
+    await handleUserInput(spinnerFake);
+
+    expect(parser.parse_args).toHaveBeenCalledTimes(1);
+    expect(mockProcessParameters).toHaveBeenCalledTimes(1);
+    expect(stderrOutput).toBe('');
+  });
+
+  it('should handle parse errors gracefully', async () => {
+    await handleUserInput(spinnerFake);
+    expect(stderrOutput.includes('the following arguments are required: -u/--url')).toBe(true);
+  });
+
+  it('should handle processing errors gracefully', async () => {
+    parseMock.mockReturnValue({ url: 'https://example.org', single_badge: false, badge_style: 'flat', save_report: false } as never);
+    mockProcessParameters.mockRejectedValue(new Error('Async error'));
+
+    await handleUserInput(spinnerFake);
+    expect(stderrOutput.includes('Error: Async error')).toBe(true);
+  });
+});
+

package/__tests__/{util.js → util.ts}

@@ -26,8 +26,9 @@ describe('test util', () => {
     const stdoutWrite = process.stdout.write;
 
     beforeEach(() => {
-      process.stdout.write = (x) => {
+      process.stdout.write = (x: string) => {
         stdoutOutput += x;
+        return true;
       };
       stdoutOutput = '';
     });
@@ -45,9 +46,10 @@ describe('test util', () => {
     it('should not write a success metric if error is thrown', () => {
       const expectedErrorMessage = 'error';
       expect(() => {
-        statusMessage('success', expectedErrorMessage, 'error');
+        statusMessage('success', expectedErrorMessage, new Error('error'));
       }).toThrow(new Error(expectedErrorMessage));
       expect(stdoutOutput).toBe('');
     });
   });
 });
+

package/dist/README.md

@@ -1,5 +1,4 @@
 [![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](https://img.shields.io/:license-mit-blue.svg?style=flat)](https://emanuelemazzotta.com/mit-license)

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lighthouse-badges",
-  "version": "1.3.16",
+  "version": "1.4.0",
   "description": "🚦Generate gh-badges (shields.io) based on Lighthouse performance.",
   "main": "src/index.js",
   "bin": {
@@ -11,8 +11,10 @@
     "app:install": "npm run build && cd dist && npm i -g .",
     "app:reinstall": "npm-run-all app:uninstall app:install",
     "app:uninstall": "npm uninstall -g @emazzotta/lighthouse-badges; npm uninstall -g .; npm uninstall -g lighthouse-badges",
-    "build": "npm run build:prepare && cp -r ./src ./dist/src",
-    "build:prepare": "npm run clean && mkdir dist && sed 's#\"dist/src/index.js\"#\"src/index.js\"#' package.json > ./dist/package.json && cp README.md dist && cp LICENSE.md dist",
+    "build": "npm run build:prepare && npm run build:compile && npm run build:copy-declarations",
+    "build:compile": "tsc",
+    "build:copy-declarations": "cp src/*.d.ts dist/src/ 2>/dev/null || true",
+    "build:prepare": "npm run clean && mkdir -p dist && 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 .",
@@ -26,9 +28,10 @@
     "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": "NODE_OPTIONS=--experimental-vm-modules jest",
     "test:all": "npm-run-all test system-test:full-run",
-    "test:related": "jest --findRelatedTests"
+    "test:related": "jest --findRelatedTests",
+    "upgrade": "npx npm-check-updates -i && npm install && npm upgrade && npm run pre-push"
   },
   "husky": {
     "hooks": {
@@ -36,7 +39,7 @@
     }
   },
   "lint-staged": {
-    "*.js": [
+    "*.{js,ts}": [
       "npm run lint:fix",
       "npm run test:related"
     ]
@@ -50,25 +53,29 @@
     "badge-maker": "^5.0.2",
     "chrome-launcher": "1.2.1",
     "clui": "^0.3.6",
-    "lighthouse": "^13.0.0",
+    "lighthouse": "^13.0.1",
     "ramda": "^0.32.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.28.0",
-    "@babel/preset-env": "^7.28.0",
-    "@eslint/js": "^9.32.0",
+    "@eslint/js": "^9.39.1",
+    "@jest/globals": "^30.2.0",
     "@types/jest": "^30.0.0",
-    "eslint": "^9.32.0",
+    "@types/node": "^24.10.0",
+    "@typescript-eslint/eslint-plugin": "^8.46.3",
+    "@typescript-eslint/parser": "^8.46.3",
+    "eslint": "^9.39.1",
+    "globals": "^16.5.0",
     "husky": "^9.1.7",
-    "jest": "^30.0.5",
+    "jest": "^30.2.0",
     "lint-staged": "^16.2.6",
-    "npm-run-all": "^4.1.5"
+    "npm-run-all": "^4.1.5",
+    "ts-jest": "^29.4.5",
+    "typescript": "^5.9.3"
   },
   "engines": {
     "npm": ">=7.0.0",
     "node": ">=18.16"
   },
-  "packageManager": "yarn@1.21.1",
   "private": false,
   "author": "Emanuele Mazzotta",
   "license": "MIT"

package/dist/src/argparse.d.ts

@@ -0,0 +1,27 @@
+declare module 'argparse' {
+  export interface ArgumentParserOptions {
+    description?: string;
+    add_help?: boolean;
+  }
+
+  export class ArgumentGroup {
+    add_argument(name: string, longName: string, options?: ArgumentOptions): void;
+  }
+
+  export interface ArgumentOptions {
+    action?: string;
+    version?: string;
+    help?: string;
+    required?: boolean;
+    choices?: string[];
+    default?: string;
+  }
+
+  export class ArgumentParser {
+    constructor(options?: ArgumentParserOptions);
+    add_argument(name: string, longName: string, options?: ArgumentOptions): void;
+    add_argument_group(options: { title: string }): ArgumentGroup;
+    parse_args(args?: string[]): Record<string, unknown>;
+  }
+}
+

package/dist/src/argparser.d.ts

@@ -0,0 +1,6 @@
+import type { ParsedArgs } from './types.js';
+declare const typedParser: {
+    parse_args: (args?: string[]) => ParsedArgs;
+};
+export default typedParser;
+//# sourceMappingURL=argparser.d.ts.map

package/dist/src/argparser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"argparser.d.ts","sourceRoot":"","sources":["../../src/argparser.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAuE7C,QAAA,MAAM,WAAW;wBACK,MAAM,EAAE,KAAG,UAAU;CAG1C,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/dist/src/argparser.js

@@ -1,53 +1,68 @@
 import fs from 'fs';
 import path from 'path';
+import { fileURLToPath } from 'url';
 import { ArgumentParser } from 'argparse';
-import * as currentPath from "./currentPath.cjs"
-
-const packageJsonPath = path.join(currentPath.default, '../package.json');
-const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-
-const parser = new ArgumentParser({
-  description: 'Generate gh-badges (shields.io) based on lighthouse performance.',
-  add_help: true
-});
-
-parser.add_argument('-v', '--version', {
-  action: 'version',
-  version: packageJson.version,
-  help: 'Show the version of the tool'
-});
-
-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', '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'
-});
-
-const requiredArgs = parser.add_argument_group({ title: 'Required arguments' });
-requiredArgs.add_argument('-u', '--url', {
-  action: 'store',
-  required: true,
-  help: 'The lighthouse badge(s) will contain the score(s) of the supplied url'
-});
-
-export default parser;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const getPackageVersion = () => {
+    const packageJsonPath = path.join(__dirname, '../package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    return packageJson.version;
+};
+const createParser = () => {
+    const parser = new ArgumentParser({
+        description: 'Generate gh-badges (shields.io) based on lighthouse performance.',
+        add_help: true,
+    });
+    addVersionArgument(parser);
+    addOptionalArguments(parser);
+    addRequiredArguments(parser);
+    return parser;
+};
+const addVersionArgument = (parser) => {
+    parser.add_argument('-v', '--version', {
+        action: 'version',
+        version: getPackageVersion(),
+        help: 'Show the version of the tool',
+    });
+};
+const addOptionalArguments = (parser) => {
+    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', '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',
+    });
+};
+const addRequiredArguments = (parser) => {
+    const requiredArgs = parser.add_argument_group({ title: 'Required arguments' });
+    requiredArgs.add_argument('-u', '--url', {
+        action: 'store',
+        required: true,
+        help: 'The lighthouse badge(s) will contain the score(s) of the supplied url',
+    });
+};
+const parser = createParser();
+const typedParser = {
+    parse_args: (args) => {
+        return parser.parse_args(args);
+    },
+};
+export default typedParser;
+//# sourceMappingURL=argparser.js.map

package/dist/src/argparser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"argparser.js","sourceRoot":"","sources":["../../src/argparser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,CAAC;AACpB,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAG1C,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClD,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;AAE3C,MAAM,iBAAiB,GAAG,GAAW,EAAE;IACrC,MAAM,eAAe,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,iBAAiB,CAAC,CAAC;IAChE,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,eAAe,EAAE,MAAM,CAAC,CAAwB,CAAC;IAChG,OAAO,WAAW,CAAC,OAAO,CAAC;AAC7B,CAAC,CAAC;AAEF,MAAM,YAAY,GAAG,GAAmB,EAAE;IACxC,MAAM,MAAM,GAAG,IAAI,cAAc,CAAC;QAChC,WAAW,EAAE,kEAAkE;QAC/E,QAAQ,EAAE,IAAI;KACf,CAAC,CAAC;IAEH,kBAAkB,CAAC,MAAM,CAAC,CAAC;IAC3B,oBAAoB,CAAC,MAAM,CAAC,CAAC;IAC7B,oBAAoB,CAAC,MAAM,CAAC,CAAC;IAE7B,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,kBAAkB,GAAG,CAAC,MAAsB,EAAQ,EAAE;IAC1D,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,WAAW,EAAE;QACrC,MAAM,EAAE,SAAS;QACjB,OAAO,EAAE,iBAAiB,EAAE;QAC5B,IAAI,EAAE,8BAA8B;KACrC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,oBAAoB,GAAG,CAAC,MAAsB,EAAQ,EAAE;IAC5D,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,gBAAgB,EAAE;QAC1C,MAAM,EAAE,YAAY;QACpB,QAAQ,EAAE,KAAK;QACf,IAAI,EAAE,2EAA2E;KAClF,CAAC,CAAC;IAEH,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,eAAe,EAAE;QACzC,MAAM,EAAE,OAAO;QACf,QAAQ,EAAE,KAAK;QACf,OAAO,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,eAAe,EAAE,QAAQ,CAAC;QACtE,OAAO,EAAE,MAAM;QACf,IAAI,EAAE,oCAAoC;KAC3C,CAAC,CAAC;IAEH,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,eAAe,EAAE;QACzC,MAAM,EAAE,OAAO;QACf,QAAQ,EAAE,KAAK;QACf,IAAI,EAAE,kCAAkC;KACzC,CAAC,CAAC;IAEH,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,eAAe,EAAE;QACzC,MAAM,EAAE,YAAY;QACpB,QAAQ,EAAE,KAAK;QACf,IAAI,EAAE,uDAAuD;KAC9D,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,oBAAoB,GAAG,CAAC,MAAsB,EAAQ,EAAE;IAC5D,MAAM,YAAY,GAAG,MAAM,CAAC,kBAAkB,CAAC,EAAE,KAAK,EAAE,oBAAoB,EAAE,CAAC,CAAC;IAChF,YAAY,CAAC,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE;QACvC,MAAM,EAAE,OAAO;QACf,QAAQ,EAAE,IAAI;QACd,IAAI,EAAE,uEAAuE;KAC9E,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,MAAM,GAAG,YAAY,EAAE,CAAC;AAE9B,MAAM,WAAW,GAAG;IAClB,UAAU,EAAE,CAAC,IAAe,EAAc,EAAE;QAC1C,OAAO,MAAM,CAAC,UAAU,CAAC,IAAI,CAA0B,CAAC;IAC1D,CAAC;CACF,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/dist/src/calculations.d.ts

@@ -0,0 +1,5 @@
+import type { LighthouseMetrics } from './types.js';
+export declare const percentageToColor: (percentage: number) => string;
+export declare const getAverageScore: (metrics: LighthouseMetrics[]) => LighthouseMetrics;
+export declare const getSquashedScore: (metrics: LighthouseMetrics[]) => LighthouseMetrics;
+//# sourceMappingURL=calculations.d.ts.map

package/dist/src/calculations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculations.d.ts","sourceRoot":"","sources":["../../src/calculations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAmBpD,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,KAAG,MAOtD,CAAC;AAYF,eAAO,MAAM,eAAe,GAAI,SAAS,iBAAiB,EAAE,KAAG,iBAgB9D,CAAC;AAcF,eAAO,MAAM,gBAAgB,GAAI,SAAS,iBAAiB,EAAE,KAAG,iBAkB/D,CAAC"}