feat(wpt): add wpt event emitter with types

Author: Seolhun

src/wpt/Wpt.ts

@@ -2,10 +2,12 @@ import lighthouse from 'lighthouse';
 import { RunnerResult } from 'lighthouse/types/externs';
 import { launch } from 'chrome-launcher';
 import { pipe, concurrent, toAsync, toArray, map } from '@fxts/core';
+import EventEmitter from 'events';
 
 import { Reporter } from './tools';
 import { WptContext, WptConfig, WptAuditPath } from './context';
 import * as constants from './constants';
+import { WptEventHandlersEventMap } from './Wpt.types';
 
 export interface WebPerformanceTesterProps {
   reporter?: Reporter;
@@ -17,21 +19,30 @@ export interface WptAuditPathItem extends WptAuditPath {
 
 const context = WptContext();
 
-class WebPerformanceTester {
+class WebPerformanceTester extends EventEmitter {
   private reporter: Reporter;
 
   constructor(props?: WebPerformanceTesterProps) {
+    super();
     this.reporter = props?.reporter ?? new Reporter();
+    this.typedEmit('onReadyWpt', { context });
+  }
+
+  private typedEmit(
+    eventName: keyof WptEventHandlersEventMap,
+    eventArgs: WptEventHandlersEventMap[keyof WptEventHandlersEventMap],
+  ) {
+    this.emit(eventName, eventArgs);
   }
 
   private async createLighthouseReport(
     lighthouseResult: RunnerResult,
     auditPath: WptAuditPathItem,
   ) {
-    console.log(`Reporter:start - "${auditPath.name}"`);
+    this.typedEmit('onReportStart', { auditPath, context });
     this.reporter.saveAuditsReportFile(lighthouseResult.report, auditPath.name);
     await this.reporter.createAuditsReport(lighthouseResult.lhr.audits);
-    console.log(`Reporter:success - "${auditPath.name}"`);
+    this.typedEmit('onReportEnd', { auditPath, context });
   }
 
   private async runLighthouse(
@@ -44,7 +55,7 @@ class WebPerformanceTester {
       port: options.port + index,
     });
     try {
-      console.log(`Lighthouse:start - "${auditPath.name}"`);
+      this.typedEmit('onStartedLighthouse', { auditPath, context });
       const lighthouseResult: RunnerResult = await lighthouse(auditPath.url, {
         ...options,
         screenEmulation:
@@ -54,22 +65,22 @@ class WebPerformanceTester {
         port: options.port + index,
       });
       await this.createLighthouseReport(lighthouseResult, auditPath);
-      console.log(
-        `Lighthouse:success - Finish the "${auditPath.name}" wpt test`,
-      );
+      this.typedEmit('onFinishedLighthouse', { auditPath, context });
     } catch (error) {
-      console.error(`Lighthouse:fail - "${auditPath.name}"`);
-      console.error('Lighthouse:fail - ', error);
+      if (error instanceof Error) {
+        this.typedEmit('onErrorLighthouse', { auditPath, context, error });
+      } else {
+        this.typedEmit('onErrorLighthouse', { auditPath, context });
+      }
     } finally {
       chrome.kill();
     }
   }
 
   async run() {
     try {
+      this.typedEmit('onStartedWpt', { context });
       let index = 0;
-
-      console.log('Run:start');
       const { concurrency, options } = context.config;
       await pipe(
         context.auditPathsItems,
@@ -81,9 +92,13 @@ class WebPerformanceTester {
         concurrent(concurrency),
         (values) => toArray(values),
       );
-      console.log('Run:success - All wpt tests were finished');
+      this.typedEmit('onFinishedWpt', { context });
     } catch (error) {
-      console.error('Run:fail - ', error);
+      if (error instanceof Error) {
+        this.typedEmit('onErrorWpt', { context, error });
+      } else {
+        this.typedEmit('onErrorWpt', { context });
+      }
     }
   }
 }

src/wpt/Wpt.types.ts

@@ -0,0 +1,30 @@
+import { WptContextValue } from './context';
+import { WptAuditPathItem } from './Wpt';
+
+export interface WptErrorEvent {
+  error: Error;
+}
+
+export interface WptEvent {
+  context: WptContextValue;
+}
+
+export interface WptLighthouseEvent extends WptEvent {
+  auditPath: WptAuditPathItem;
+}
+
+export interface WptReportEvent extends WptEvent {
+  auditPath: WptAuditPathItem;
+}
+
+export interface WptEventHandlersEventMap {
+  onReadyWpt: WptEvent;
+  onStartedWpt: WptEvent;
+  onFinishedWpt: WptEvent;
+  onErrorWpt: WptEvent & WptErrorEvent;
+  onStartedLighthouse: WptLighthouseEvent;
+  onFinishedLighthouse: WptLighthouseEvent;
+  onErrorLighthouse: WptLighthouseEvent & WptErrorEvent;
+  onReportStart: WptReportEvent;
+  onReportEnd: WptReportEvent;
+}