Refactor TypeScript for readability, drop ramda, bump to 1.5.0

Replace Ramda calls with native Array/Object methods, swap hand-rolled
callback promisification for fs/promises, inline trivial wrappers, fold
the fake Promise.all([single]) ceremony, and let errors propagate
naturally instead of going through the awkward statusMessage helper.
Make percentageToColor table-driven and delete the unused zip helper.
All 29 tests still pass; tsc and eslint are clean.

Author: emazzotta

__tests__/util.test.ts

@@ -1,56 +1,16 @@
-import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
-import { urlEscaper, zip, statusMessage } from '../src/util';
+import { describe, it, expect } from 'bun:test';
+import { urlEscaper } from '../src/util';
 
-describe('test util', () => {
-  describe('test pure functions in util', () => {
-    it('should return escaped https url', () => {
-      const actualUrl = 'https://abcöd%f&/?get=hi';
-      const expectedUrl = 'abc_d_f___get_hi';
-      expect(urlEscaper(actualUrl)).toBe(expectedUrl);
-    });
-
-    it('should return escaped http url', () => {
-      const actualUrl = 'https://abcöd%f&/?get=hi';
-      const expectedUrl = 'abc_d_f___get_hi';
-      expect(urlEscaper(actualUrl)).toBe(expectedUrl);
-    });
-
-    it('should zip together two arrays', () => {
-      const input = [[0, 1, 2, 3], [4, 5, 6, 7]];
-      const expected = [[0, 4], [1, 5], [2, 6], [3, 7]];
-      expect(zip(input)).toStrictEqual(expected);
-    });
+describe('urlEscaper', () => {
+  it('strips the https scheme and replaces non-alphanumerics', () => {
+    expect(urlEscaper('https://abcöd%f&/?get=hi')).toBe('abc_d_f___get_hi');
   });
 
-  describe('test functions with side-effects in util', () => {
-    let stdoutOutput = '';
-    const stdoutWrite = process.stdout.write;
-
-    beforeEach(() => {
-      process.stdout.write = (x: string) => {
-        stdoutOutput += x;
-        return true;
-      };
-      stdoutOutput = '';
-    });
-
-    afterEach(() => {
-      process.stdout.write = stdoutWrite;
-    });
-
-    it('should write success message if no error', () => {
-      const expectedSuccessMessage = 'success';
-      statusMessage(expectedSuccessMessage, 'error', undefined);
-      expect(stdoutOutput).toBe(expectedSuccessMessage);
-    });
+  it('strips the http scheme and replaces non-alphanumerics', () => {
+    expect(urlEscaper('http://abcöd%f&/?get=hi')).toBe('abc_d_f___get_hi');
+  });
 
-    it('should not write a success metric if error is thrown', () => {
-      const expectedErrorMessage = 'error';
-      expect(() => {
-        statusMessage('success', expectedErrorMessage, new Error('error'));
-      }).toThrow(new Error(expectedErrorMessage));
-      expect(stdoutOutput).toBe('');
-    });
+  it('lowercases the result', () => {
+    expect(urlEscaper('HTTPS://Example.COM/Path')).toBe('example_com_path');
   });
 });
-

bun.lock

@@ -1,6 +1,6 @@
 {
   "name": "@emazzotta/lighthouse-badges",
-  "version": "1.4.5",
+  "version": "1.5.0",
   "description": "🚦Generate gh-badges (shields.io) based on Lighthouse performance.",
   "main": "dist/src/index.js",
   "bin": {
@@ -52,8 +52,7 @@
     "badge-maker": "^5.0.2",
     "chrome-launcher": "1.2.1",
     "clui": "^0.3.6",
-    "lighthouse": "^13.1.0",
-    "ramda": "^0.32.0"
+    "lighthouse": "^13.1.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",

package.json

@@ -1,88 +1,42 @@
-import * as R from 'ramda';
 import type { LighthouseMetrics } from './types.js';
 
-const PERCENTAGE_THRESHOLDS = {
-  EXCELLENT: 95,
-  GOOD: 90,
-  ABOVE_AVERAGE: 75,
-  AVERAGE: 60,
-  BELOW_AVERAGE: 40,
-} as const;
+const COLOR_THRESHOLDS: ReadonlyArray<readonly [number, string]> = [
+  [95, 'brightgreen'],
+  [90, 'green'],
+  [75, 'yellowgreen'],
+  [60, 'yellow'],
+  [40, 'orange'],
+];
 
-const COLOR_MAP = {
-  EXCELLENT: 'brightgreen',
-  GOOD: 'green',
-  ABOVE_AVERAGE: 'yellowgreen',
-  AVERAGE: 'yellow',
-  BELOW_AVERAGE: 'orange',
-  POOR: 'red',
-} as const;
+const POOR_COLOR = 'red';
 
-export const percentageToColor = (percentage: number): string => {
-  if (percentage >= PERCENTAGE_THRESHOLDS.EXCELLENT) return COLOR_MAP.EXCELLENT;
-  if (percentage >= PERCENTAGE_THRESHOLDS.GOOD) return COLOR_MAP.GOOD;
-  if (percentage >= PERCENTAGE_THRESHOLDS.ABOVE_AVERAGE) return COLOR_MAP.ABOVE_AVERAGE;
-  if (percentage >= PERCENTAGE_THRESHOLDS.AVERAGE) return COLOR_MAP.AVERAGE;
-  if (percentage >= PERCENTAGE_THRESHOLDS.BELOW_AVERAGE) return COLOR_MAP.BELOW_AVERAGE;
-  return COLOR_MAP.POOR;
-};
+export const percentageToColor = (percentage: number): string =>
+  COLOR_THRESHOLDS.find(([threshold]) => percentage >= threshold)?.[1] ?? POOR_COLOR;
 
-const calculateCategoryAverage = (
-  category: string,
-  metrics: LighthouseMetrics[],
-): number => {
-  const categoryScores = R.pluck(category, metrics);
-  const sum = R.sum(categoryScores);
-  const count = R.length(metrics);
-  return Math.round(sum / count);
+const averageByCategory = (category: string, metrics: LighthouseMetrics[]): number => {
+  const sum = metrics.reduce((total, metric) => total + (metric[category] ?? 0), 0);
+  return Math.round(sum / metrics.length);
 };
 
 export const getAverageScore = (metrics: LighthouseMetrics[]): LighthouseMetrics => {
-  if (metrics.length === 0) {
-    return {};
-  }
-
-  const headMetric = R.head(metrics);
-  if (!headMetric) {
-    return {};
-  }
-
-  const categories = R.keys(headMetric);
-  const scoreObjects = categories.map((category: string) => ({
-    [category]: calculateCategoryAverage(category, metrics),
-  }));
-
-  return R.mergeAll(scoreObjects) as LighthouseMetrics;
-};
-
-const calculateTotalScore = (metrics: LighthouseMetrics[]): number => {
-  const sumOfAllScores = R.pipe(
-    R.map((metric: LighthouseMetrics) => R.sum(R.values(metric))),
-    R.sum,
-  )(metrics);
-  return sumOfAllScores;
-};
+  const [head] = metrics;
+  if (!head) return {};
 
-const calculateTotalCategories = (headMetric: LighthouseMetrics): number => {
-  return R.length(R.keys(headMetric));
+  return Object.fromEntries(
+    Object.keys(head).map((category) => [category, averageByCategory(category, metrics)]),
+  );
 };
 
 export const getSquashedScore = (metrics: LighthouseMetrics[]): LighthouseMetrics => {
-  if (metrics.length === 0) {
-    return { lighthouse: 0 };
-  }
-
-  const headMetric = R.head(metrics);
-  if (!headMetric) {
-    return { lighthouse: 0 };
-  }
+  const [head] = metrics;
+  if (!head) return { lighthouse: 0 };
 
-  const totalScore = calculateTotalScore(metrics);
-  const totalCategories = calculateTotalCategories(headMetric);
-  const totalMetrics = R.length(metrics);
-  const averageScore = totalScore / (totalMetrics * totalCategories);
+  const totalScore = metrics.reduce(
+    (sum, metric) => sum + Object.values(metric).reduce((a, b) => a + b, 0),
+    0,
+  );
+  const totalCategories = Object.keys(head).length;
+  const averageScore = totalScore / (metrics.length * totalCategories);
 
-  return {
-    lighthouse: Math.round(averageScore),
-  };
+  return { lighthouse: Math.round(averageScore) };
 };

src/calculations.ts

@@ -3,6 +3,5 @@
 import handleUserInput from './main.js';
 import CLI from 'clui';
 
-const CLI_SPINNER = new CLI.Spinner('Running Lighthouse, please wait...', ['◜', '◠', '◝', '◞', '◡', '◟']);
-handleUserInput(CLI_SPINNER).then(() => {});
-
+const spinner = new CLI.Spinner('Running Lighthouse, please wait...', ['◜', '◠', '◝', '◞', '◡', '◟']);
+await handleUserInput(spinner);