Restrict Multicaster callback type

Only allow standard (err, result) callbacks, so that we can bridge them
to promises.

src/common/lib/client/auth.ts

@@ -116,7 +116,7 @@ class Auth {
   client: BaseClient;
   tokenParams: API.TokenParams;
   currentTokenRequestId: number | null;
-  waitingForTokenRequest: MulticasterInstance | null;
+  waitingForTokenRequest: MulticasterInstance<API.TokenDetails> | null;
   // This initialization is always overwritten and only used to prevent a TypeScript compiler error
   authOptions: API.AuthOptions = {} as API.AuthOptions;
   tokenDetails?: API.TokenDetails | null;
@@ -959,7 +959,7 @@ class Auth {
 
     /* Request a new token */
     const tokenRequestId = (this.currentTokenRequestId = getTokenRequestId());
-    this.requestToken(this.tokenParams, this.authOptions, (err: Function, tokenResponse?: API.TokenDetails) => {
+    this.requestToken(this.tokenParams, this.authOptions, (err: ErrorInfo | null, tokenResponse?: API.TokenDetails) => {
       if ((this.currentTokenRequestId as number) > tokenRequestId) {
         Logger.logAction(
           Logger.LOG_MINOR,

src/common/lib/transport/connectionmanager.ts

@@ -1951,10 +1951,10 @@ class ConnectionManager extends EventEmitter {
      * the dup, they'll be lost */
     if (lastQueued && !lastQueued.sendAttempted && bundleWith(lastQueued.message, msg, maxSize)) {
       if (!lastQueued.merged) {
-        lastQueued.callback = Multicaster.create([lastQueued.callback as any]);
+        lastQueued.callback = Multicaster.create([lastQueued.callback]);
         lastQueued.merged = true;
       }
-      (lastQueued.callback as MulticasterInstance).push(callback as any);
+      (lastQueued.callback as MulticasterInstance<void>).push(callback);
     } else {
       this.queuedMessages.push(new PendingMessage(msg, callback));
     }

src/common/lib/util/multicaster.ts

@@ -1,25 +1,25 @@
+import { StandardCallback } from 'common/types/utils';
+import ErrorInfo from 'common/lib/types/errorinfo';
 import Logger from './logger';
 
-type AnyFunction = (...args: any[]) => unknown;
-
-export interface MulticasterInstance extends Function {
-  (...args: unknown[]): void;
-  push: (fn: AnyFunction) => void;
+export interface MulticasterInstance<T> extends Function {
+  (err?: ErrorInfo | null, result?: T): void;
+  push: (fn: StandardCallback<T>) => void;
 }
 
-class Multicaster {
-  members: Array<AnyFunction>;
+class Multicaster<T> {
+  members: Array<StandardCallback<T>>;
 
   // Private constructor; use static Multicaster.create instead
-  private constructor(members?: Array<AnyFunction | undefined>) {
-    this.members = (members as Array<AnyFunction>) || [];
+  private constructor(members?: Array<StandardCallback<T> | undefined>) {
+    this.members = (members as Array<StandardCallback<T>>) || [];
   }
 
-  private call(...args: unknown[]): void {
+  private call(err?: ErrorInfo | null, result?: T): void {
     for (const member of this.members) {
       if (member) {
         try {
-          member(...args);
+          member(err, result);
         } catch (e) {
           Logger.logAction(
             Logger.LOG_ERROR,
@@ -31,14 +31,14 @@ class Multicaster {
     }
   }
 
-  push(...args: Array<AnyFunction>): void {
+  push(...args: Array<StandardCallback<T>>): void {
     this.members.push(...args);
   }
 
-  static create(members?: Array<AnyFunction | undefined>): MulticasterInstance {
+  static create<T>(members?: Array<StandardCallback<T> | undefined>): MulticasterInstance<T> {
     const instance = new Multicaster(members);
-    return Object.assign((...args: unknown[]) => instance.call(...args), {
-      push: (fn: AnyFunction) => instance.push(fn),
+    return Object.assign((err?: ErrorInfo | null, result?: T) => instance.call(err, result), {
+      push: (fn: StandardCallback<T>) => instance.push(fn),
     });
   }
 }