Library improvements

- Typescript generics for AsyncQueue
- Replace .bind(this) for arrow functions

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asanrom/async-tools",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Collection of tools to work with async functions.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

src/async-interval.ts

@@ -5,7 +5,7 @@
 import { EventEmitter } from "events";
 
 /**
- * Interval that waits for async funcions to complete
+ * Interval that waits for async functions to complete
  */
 export class AsyncInterval extends EventEmitter {
     public interval: NodeJS.Timeout;

src/async-queue.ts

@@ -6,18 +6,18 @@ import { EventEmitter } from "events";
 
 /**
  * Async queue
- * Handles each item with an async funcion
- * Waits for the funcion to end before handling the next item
+ * Handles each item with an async function
+ * Waits for the function to end before handling the next item
  * Allows a max size setting
  */
-export class AsyncQueue extends EventEmitter {
+export class AsyncQueue<T = any> extends EventEmitter {
 
     // Config
     private size: number;
-    private dispatchFunc: (t: any) => any;
+    private dispatchFunc: (t: T) => any;
 
     // Status
-    private array: any[];
+    private array: T[];
     private waiting: boolean;
     private toResolve: () => any;
     private destroyed: boolean;
@@ -27,7 +27,7 @@ export class AsyncQueue extends EventEmitter {
      * @param size Max size of the queue. Set to 0 for no size limit.
      * @param dispatchFunc Dispatch function
      */
-    constructor(size: number, dispatchFunc: (t: any) => any) {
+    constructor(size: number, dispatchFunc: (t: T) => any) {
         super();
 
         this.array = [];
@@ -62,7 +62,7 @@ export class AsyncQueue extends EventEmitter {
      * @param item The item
      * @returns true if it was added, false if it was dropped
      */
-    public push(item: any): boolean {
+    public push(item: T): boolean {
         if (this.destroyed) {
             this.emit('error', new Error("Push() was called after the queue was destroyed"));
             return;
@@ -96,13 +96,13 @@ export class AsyncQueue extends EventEmitter {
         this.dispatchFunc = async function () { };
 
         // Wait if there is an item running
-        return new Promise<void>(function (resolve) {
+        return new Promise<void>(resolve => {
             if (this.waiting) {
                 resolve();
             } else {
                 this.toResolve = resolve;
             }
-        }.bind(this));
+        });
     }
 
     private dispatchNext() {
@@ -118,10 +118,10 @@ export class AsyncQueue extends EventEmitter {
 
             if (result instanceof Promise) {
                 result.then(this.dispatchNext.bind(this))
-                    .catch(function (err: Error) {
+                    .catch(err => {
                         this.emit('error', err);
                         this.dispatchNext();
-                    }.bind(this));
+                    })
             } else {
                 this.dispatchNext();
             }

src/async-semaphore.ts

@@ -10,7 +10,7 @@ interface Waiter {
 
 /**
  * Async semaphore
- * To create critical sections of async funcions
+ * To create critical sections of async functions
  */
 export class AsyncSemaphore {
     // Free Instances
@@ -52,14 +52,14 @@ export class AsyncSemaphore {
             // Can be adquired
             this.instances -= instances;
         } else {
-            return new Promise<void>(function (resolve, reject) {
+            return new Promise<void>((resolve, reject) => {
                 // Add to queue
                 this.waiting.push({
                     requiredInstances: instances,
                     resolve: resolve,
                     reject: reject,
                 })
-            }.bind(this));
+            });
         }
     }
 

tests/async-queue.ts

@@ -16,7 +16,7 @@ describe("Async Queue", () => {
         let items = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 
         return new Promise<void>((resolve, reject) => {
-            const q: AsyncQueue = new AsyncQueue(0, async (item) => {
+            const q: AsyncQueue = new AsyncQueue<number>(0, async (item) => {
                 if (items[counter] !== item) {
                     q.destroy();
                     return reject(new Error(`Expected ${items[counter]} but found ${item}`));
@@ -46,7 +46,7 @@ describe("Async Queue", () => {
         let items = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 
         return new Promise<void>((resolve, reject) => {
-            const q: AsyncQueue = new AsyncQueue(0, async (item) => {
+            const q: AsyncQueue = new AsyncQueue<number>(0, async (item) => {
                 if (items[counter] !== item) {
                     q.destroy();
                     return reject(new Error(`Expected ${items[counter]} but found ${item}`));
@@ -77,7 +77,7 @@ describe("Async Queue", () => {
         let destroyed = false;
 
         return new Promise<void>((resolve, reject) => {
-            const q: AsyncQueue = new AsyncQueue(0, async (item) => {
+            const q: AsyncQueue = new AsyncQueue<number>(0, async (item) => {
                 if (destroyed) {
                     reject(new Error("Item handled after destroy"));
                     return;
@@ -110,7 +110,7 @@ describe("Async Queue", () => {
         let destroyed = false;
 
         return new Promise<void>((resolve, reject) => {
-            const q: AsyncQueue = new AsyncQueue(5, async (item) => {
+            const q: AsyncQueue = new AsyncQueue<number>(5, async (item) => {
                 if (destroyed) {
                     reject(new Error("Item handled after destroy"));
                     return;
@@ -141,5 +141,4 @@ describe("Async Queue", () => {
             });
         });
     });
-
 });