feat(ts) migrate AsyncQueue to TS

modules/util/AsyncQueue.js → modules/util/AsyncQueue.ts

 import { getLogger } from '@jitsi/logger';
-import { queue } from 'async-es';
+import { queue, AsyncQueue as AsyncQueueType } from 'async-es';
 
 const logger = getLogger('modules/util/AsyncQueue');
 
     /**
      * Creates new instance.
      */
-    constructor(message) {
+    constructor(message: string) {
         super(message);
         this.name = 'ClearedQueueError';
     }
 }
 
+export type Task = (callback: (err?: Error) => void) => void;
+export type TaskCallback = (err?: Error) => void;
+
 /**
  * A queue for async task execution.
  */
 export default class AsyncQueue {
+    private _queue: AsyncQueueType<Task>;
+    private _stopped: boolean;
+    private _taskCallbacks: Map<Task, TaskCallback | undefined>;
+
     /**
      * Creates new instance.
      */
     /**
      * Removes any pending tasks from the queue.
      */
-    clear() {
+    clear(): void {
         for (const finishedCallback of this._taskCallbacks.values()) {
             try {
                 finishedCallback?.(new ClearedQueueError('The queue has been cleared'));
     /**
      * Internal task processing implementation which makes things work.
      */
-    _processQueueTasks(task, finishedCallback) {
+    private _processQueueTasks(task: Task, finishedCallback: TaskCallback): void {
         try {
             task(finishedCallback);
         } catch (error) {
     /**
      * Pauses the execution of the tasks on the queue.
      */
-    pause() {
+    pause(): void {
         this._queue.pause();
     }
 
      *     }
      * });
      *
-     * @param {function} task - The task to be executed. See the description above.
-     * @param {function} [callback] - Optional callback to be called after the task has been executed.
+     * @param {Task} task - The task to be executed. See the description above.
+     * @param {TaskCallback} [callback] - Optional callback to be called after the task has been executed.
      */
-    push(task, callback) {
+    push(task: Task, callback?: TaskCallback): void {
         if (this._stopped) {
             callback && callback(new Error('The queue has been stopped'));
 
     /**
      * Resumes the execution of the tasks on the queue.
      */
-    resume() {
+    resume(): void {
         this._queue.resume();
     }
 
      * Shutdowns the queue. All already queued tasks will execute, but no future tasks can be added. If a task is added
      * after the queue has been shutdown then the callback will be called with an error.
      */
-    shutdown() {
+    shutdown(): void {
         this._stopped = true;
     }
 }