refactor: Move FolderWatcher and ManagedChildProcess to use TypedEmitter

Author: colin969

package-lock.json

@@ -2,32 +2,15 @@ import { INamedBackProcessInfo } from '@shared/interfaces';
 import * as Coerce from '@shared/utils/Coerce';
 import { ChildProcess, spawn } from 'child_process';
 import { EventEmitter } from 'events';
-import { IBackProcessInfo, ILogPreEntry } from 'flashpoint-launcher';
+import { IBackProcessInfo, ManagedChildProcessEvents, ProcessState } from 'flashpoint-launcher';
 import * as readline from 'readline';
 import * as kill from 'tree-kill';
+import { TypedEmitter } from 'typed-emitter';
 import { onServiceChange } from './util/events';
 import { Disposable } from './util/lifecycle';
-import { ProcessState } from 'flashpoint-launcher';
 
 const { str } = Coerce;
 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-export interface ManagedChildProcess {
-  /**
-   * Fires when any background service prints to std{out,err}. Every line is
-   * prefixed with the name of the process and the output is guaranteed to end
-   * with a new line.
-   */
-  on(event: 'output', handler: (output: ILogPreEntry) => void): this;
-  emit(event: 'output', output: ILogPreEntry): boolean;
-  /** Fires whenever the status of a process changes. */
-  on(event: 'change', listener: (newState: ProcessState) => void): this;
-  emit(event: 'change', newState: ProcessState): boolean;
-  /** Fires whenever the process exits */
-  on(event: 'exit', listener: (code: number | null, signal: string | null) => void): this;
-  emit(event: 'exit', code: number | null, signal: string | null): boolean;
-}
-
 export type ProcessOpts = {
   detached?: boolean;
   autoRestart?: boolean;
@@ -40,8 +23,7 @@ export type ProcessOpts = {
 const MAX_RESTARTS = 5;
 
 /** Manages a single process. Wrapper around node's ChildProcess. */
-// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-export class ManagedChildProcess extends EventEmitter {
+export class ManagedChildProcess extends (EventEmitter as new () => TypedEmitter<ManagedChildProcessEvents>) {
   // @TODO Add timeouts for restarting and killing the process (it should give up after some time, like 10 seconds) maybe?
 
   public id: string;

src/back/ManagedChildProcess.ts

@@ -2,7 +2,8 @@ import { debounce } from '@shared/utils/debounce';
 import * as chokidar from 'chokidar';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { WrappedEventEmitter } from './WrappedEventEmitter';
+import { EventEmitter } from 'node:stream';
+import { TypedEmitter } from 'typed-emitter';
 
 type IMap<K extends string | number, V> = { [key in K]: V; };
 
@@ -11,31 +12,20 @@ export type FolderWatcherOptions = {
   changeDebounce?: number;
 }
 
+type FolderWatcherEvents = {
+  ready: () => void;
+  change: (filename: string, offsetPath: string) => void;
+  add: (filename: string, offsetPath: string) => void;
+  remove: (filename: string, stats: fs.Stats, offsetPath: string) => void;
+  error: (error: Error) => void;
+}
+
 /**
  * Watches a folder and its child files/folders for changes using chokidar.
  * Recursive watching is optional.
  * An instance of this can only be used to watch one folder once, you can not watch after aborting.
  */
-export class FolderWatcher extends WrappedEventEmitter {
-  // Override the base class methods with specific overloads
-  on(event: 'ready', listener: () => void): this;
-  on(event: 'change', listener: (filename: string, offsetPath: string) => void): this;
-  on(event: 'add', listener: (filename: string, offsetPath: string) => void): this;
-  on(event: 'remove', listener: (filename: string, stats: fs.Stats, offsetPath: string) => void): this;
-  on(event: 'error', listener: (error: Error) => void): this;
-  on(event: string, listener: (...args: any[]) => void): this {
-    return super.on(event, listener);
-  }
-
-  once(event: 'ready', listener: () => void): this;
-  once(event: 'change', listener: (filename: string, offsetPath: string) => void): this;
-  once(event: 'add', listener: (filename: string, offsetPath: string) => void): this;
-  once(event: 'remove', listener: (filename: string, stats: fs.Stats, offsetPath: string) => void): this;
-  once(event: 'error', listener: (error: Error) => void): this;
-  once(event: string, listener: (...args: any[]) => void): this {
-    return super.once(event, listener);
-  }
-
+export class FolderWatcher extends (EventEmitter as new () => TypedEmitter<FolderWatcherEvents>) {
   /** Chokidar watcher instance. */
   protected _watcher: chokidar.FSWatcher | undefined;
   /** Map of child files/folders of the watched folder (["filename"] = "file stats"). */

src/back/util/FolderWatcher.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
 // Type definitions for non-npm package flashpoint-launcher 12.2
 // Project: Flashpoint Launcher https://github.com/FlashpointProject/launcher
 // Definitions by: Colin Berry <https://github.com/colin969>
@@ -24,6 +23,7 @@
 declare module 'flashpoint-launcher' {
   import { FlashpointArchive, GameSearch } from '@fparchive/flashpoint-archive';
   import { Readable } from 'stream';
+  import { TypedEmitter } from 'typed-emitter';
 
   /** Version of the Flashpoint Launcher */
   const version: string;
@@ -1398,16 +1398,13 @@ declare module 'flashpoint-launcher' {
     state: DownloaderStatus;
   }
 
-  interface ManagedChildProcess {
-    /** Fires whenever the status of a process changes. */
-    on(event: 'change', listener: (newState: ProcessState) => void): this;
-    emit(event: 'change', newState: ProcessState): boolean;
-    /** Fires whenever the process exits */
-    on(event: 'exit', listener: (code: number | null, signal: string | null) => void): this;
-    emit(event: 'exit', code: number | null, signal: string | null): boolean;
+  type ManagedChildProcessEvents = {
+    output: (output: ILogPreEntry) => void;
+    change: (newState: ProcessState) => void;
+    exit: (code: number | null, signal: string | null) => void;
   }
 
-  class ManagedChildProcess {
+  class ManagedChildProcess extends TypedEmitter<ManagedChildProcessEvents> {
     /** ID of the process */
     id: string;
     /** Info this process was created with */
@@ -3639,3 +3636,53 @@ declare module 'flashpoint-launcher-renderer-ext/actions/main' {
   const removeGameSidebarComponent: ActionCreatorWithPayload<DisplaySettingsGameSidebarAction>;
   const setExtConfigValue: ActionCreatorWithPayload<ExtConfigValueAction>;
 }
+
+/**
+ * Typings lifted from typed-emitter NPM
+ * https://github.com/andywer/typed-emitter
+ *
+ * MIT License, Copyright (c) 2018 Andy Wermke
+ **/
+declare module 'typed-emitter' {
+  export type EventMap = {
+    [key: string]: (...args: any[]) => void
+  }
+
+  /**
+   * Type-safe event emitter.
+   *
+   * Use it like this:
+   *
+   * ```typescript
+   * type MyEvents = {
+   *   error: (error: Error) => void;
+   *   message: (from: string, content: string) => void;
+   * }
+   *
+   * const myEmitter = new EventEmitter() as TypedEmitter<MyEvents>;
+   *
+   * myEmitter.emit("error", "x")  // <- Will catch this type error;
+   * ```
+   */
+  export interface TypedEmitter<Events extends EventMap> {
+    addListener<E extends keyof Events> (event: E, listener: Events[E]): this
+    on<E extends keyof Events> (event: E, listener: Events[E]): this
+    once<E extends keyof Events> (event: E, listener: Events[E]): this
+    prependListener<E extends keyof Events> (event: E, listener: Events[E]): this
+    prependOnceListener<E extends keyof Events> (event: E, listener: Events[E]): this
+
+    off<E extends keyof Events>(event: E, listener: Events[E]): this
+    removeAllListeners<E extends keyof Events> (event?: E): this
+    removeListener<E extends keyof Events> (event: E, listener: Events[E]): this
+
+    emit<E extends keyof Events> (event: E, ...args: Parameters<Events[E]>): boolean
+    // The sloppy `eventNames()` return type is to mitigate type incompatibilities - see #5
+    eventNames (): (keyof Events | string | symbol)[]
+    rawListeners<E extends keyof Events> (event: E): Events[E][]
+    listeners<E extends keyof Events> (event: E): Events[E][]
+    listenerCount<E extends keyof Events> (event: E): number
+
+    getMaxListeners (): number
+    setMaxListeners (maxListeners: number): this
+  }
+}