refactor(multiple): improve types

Author: jamOne-

Diff for: src/google-maps/map-event-manager.ts

@@ -12,10 +12,10 @@ import {switchMap} from 'rxjs/operators';
 
 type MapEventManagerTarget =
   | {
-      addListener: (
+      addListener<T>(
         name: string,
-        callback: (...args: unknown[]) => void,
-      ) => google.maps.MapsEventListener | undefined;
+        callback: (args: T) => void,
+      ): google.maps.MapsEventListener | undefined;
     }
   | undefined;
 
@@ -48,8 +48,8 @@ export class MapEventManager {
             return undefined;
           }
 
-          const listener = target.addListener(name, (event: unknown) => {
-            this._ngZone.run(() => observer.next(event as T));
+          const listener = target.addListener(name, (event: T) => {
+            this._ngZone.run(() => observer.next(event));
           });
 
           // If there's an error when initializing the Maps API (e.g. a wrong API key), it will

Diff for: src/universal-app/hydration.e2e.spec.ts

@@ -1,10 +1,13 @@
 import {browser, by, element, ExpectedConditions} from 'protractor';
 
-// Expect `ngDevMode` to be always set:
-declare const ngDevMode: {
-  hydratedComponents: number;
-  componentsSkippedHydration: number;
-};
+declare global {
+  interface Window {
+    ngDevMode: {
+      hydratedComponents: number;
+      componentsSkippedHydration: number;
+    };
+  }
+}
 
 describe('hydration e2e', () => {
   beforeEach(async () => {
@@ -33,7 +36,7 @@ async function getHydrationState() {
     hydratedComponents: number;
     componentsSkippedHydration: number;
   }>(() => ({
-    hydratedComponents: ngDevMode.hydratedComponents,
-    componentsSkippedHydration: ngDevMode.componentsSkippedHydration,
+    hydratedComponents: window.ngDevMode.hydratedComponents,
+    componentsSkippedHydration: window.ngDevMode.componentsSkippedHydration,
   }));
 }

Diff for: src/universal-app/kitchen-sink/kitchen-sink.ts

@@ -69,7 +69,7 @@ interface ElementItem {
 }
 
 export class TableDataSource extends DataSource<ElementItem> {
-  connect(): Observable<Array<ElementItem>> {
+  connect(): Observable<ElementItem[]> {
     return observableOf([
       {position: 1, name: 'Hydrogen', weight: 1.0079, symbol: 'H'},
       {position: 2, name: 'Helium', weight: 4.0026, symbol: 'He'},
@@ -84,7 +84,7 @@ export class TableDataSource extends DataSource<ElementItem> {
     ]);
   }
 
-  override disconnect() {}
+  disconnect() {}
 }
 
 export const AUTOMATED_KITCHEN_SINK = new InjectionToken<boolean>('AUTOMATED_KITCHEN_SINK');

Diff for: src/youtube-player/fake-youtube-player.ts

@@ -30,6 +30,11 @@ interface FakeYtNamespace {
   namespace: typeof YT;
 }
 
+type ListenersStore<EventName extends keyof YT.Events> = {[E in EventName]?: Set<Listener<E>>};
+type Listener<EventName extends keyof YT.Events> = NonNullable<YT.Events[EventName]>;
+type ListenerArg<EventName extends keyof YT.Events> =
+  Listener<EventName> extends YT.PlayerEventHandler<infer T> ? T : never;
+
 export function createFakeYtNamespace(): FakeYtNamespace {
   const playerSpy: jasmine.SpyObj<YT.Player> = jasmine.createSpyObj('Player', [
     'getPlayerState',
@@ -63,7 +68,7 @@ export function createFakeYtNamespace(): FakeYtNamespace {
   ]);
 
   let playerConfig: YT.PlayerOptions | undefined;
-  const boundListeners = new Map<keyof YT.Events, Set<(event: unknown) => void>>();
+  const boundListeners: ListenersStore<keyof YT.Events> = {};
   const playerCtorSpy = jasmine.createSpy('Player Constructor');
 
   // The spy target function cannot be an arrow-function as this breaks when created through `new`.
@@ -72,28 +77,27 @@ export function createFakeYtNamespace(): FakeYtNamespace {
     return playerSpy;
   });
 
-  playerSpy.addEventListener.and.callFake(
-    (name: keyof YT.Events, listener: (e: unknown) => unknown) => {
-      if (!boundListeners.has(name)) {
-        boundListeners.set(name, new Set());
-      }
-      boundListeners.get(name)!.add(listener);
-    },
-  );
+  playerSpy.addEventListener.and.callFake((name, listener) => {
+    const store: ListenersStore<typeof name> = boundListeners;
+    if (!store[name]) {
+      store[name] = new Set();
+    }
+    store[name].add(listener);
+  });
 
-  playerSpy.removeEventListener.and.callFake(
-    (name: keyof YT.Events, listener: (e: unknown) => unknown) => {
-      boundListeners.get(name)?.delete(listener);
-    },
-  );
+  playerSpy.removeEventListener.and.callFake((name, listener) => {
+    boundListeners[name]?.delete(listener);
+  });
 
-  function eventHandlerFactory(name: keyof YT.Events) {
-    return (arg: Object = {}) => {
+  function eventHandlerFactory<EventName extends keyof YT.Events>(name: EventName) {
+    return (arg = {} as ListenerArg<EventName>) => {
       if (!playerConfig) {
         throw new Error(`Player not initialized before ${name} called`);
       }
 
-      boundListeners.get(name)?.forEach(callback => callback(arg));
+      boundListeners[name]?.forEach(callback =>
+        (callback as (arg: ListenerArg<EventName>) => void)(arg),
+      );
     };
   }