feat(ts) migrate modules\util\Deferred to TS

globals.d.ts

 export {};
 
-declare global {    
+declare global {
     type Timeout = ReturnType<typeof setTimeout>;
     interface Window {
         connectionTimes: any;

modules/util/Deferred.js → modules/util/Deferred.ts

-
 /**
  * Promise-like object which can be passed around for resolving it later. It
  * implements the "thenable" interface, so it can be used wherever a Promise
  *
  * In addition a "reject on timeout" functionality is provided.
  */
-export default class Deferred {
+export default class Deferred<T = any> {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+    then: Promise<T>['then'];
+    catch: Promise<T>['catch'];
+    private _timeout?: Timeout;
+
     /**
      * Instantiates a Deferred object.
      */
     constructor() {
-        this.promise = new Promise((resolve, reject) => {
-            this.resolve = (...args) => {
+        this.promise = new Promise<T>((resolve, reject) => {
+            this.resolve = (value: T | PromiseLike<T>) => {
                 this.clearRejectTimeout();
-                resolve(...args);
+                resolve(value);
             };
-            this.reject = (...args) => {
+            this.reject = (reason?: any) => {
                 this.clearRejectTimeout();
-                reject(...args);
+                reject(reason);
             };
         });
         this.then = this.promise.then.bind(this.promise);
     /**
      * Clears the reject timeout.
      */
-    clearRejectTimeout() {
+    clearRejectTimeout(): void {
         clearTimeout(this._timeout);
     }
 
     /**
      * Rejects the promise after the given timeout.
      */
-    setRejectTimeout(ms) {
+    setRejectTimeout(ms: number): void {
         this._timeout = setTimeout(() => {
             this.reject(new Error('timeout'));
         }, ms);