Bump version to v0.2.0.

Author: ghosind

lib/pool.d.ts

@@ -6,13 +6,19 @@ interface TaskPoolOptions {
      * A positive number or zero to indicates maximum concurrency limit number, no limitation if it's
      * set to 0 (similar with `Promise.all()`).
      */
-    concurrency: number;
+    concurrency?: number;
+    /**
+     * Is throws error and terminates tasks if some task threw error, default true.
+     */
+    throwsError?: boolean;
 }
 export declare class TaskPool extends EventEmitter {
     private readonly DEFAULT_CONCURRENCY;
     private tasks;
     private concurrency;
+    private throwsError;
     private resolutions;
+    private errors;
     private isRunning;
     private queue;
     private running;
@@ -30,7 +36,12 @@ export declare class TaskPool extends EventEmitter {
      * Add a task or tasks array into pool.
      * @param task Task instance or task instances array.
      */
-    addTask(task: Task | Task[]): void;
+    addTask(task: Task): number;
+    /**
+     * Add tasks array into pool.
+     * @param tasks Task instances array.
+     */
+    addTasks(tasks: Task | Task[]): number[];
     /**
      * Execute all tasks in the pool.
      * @async
@@ -41,9 +52,18 @@ export declare class TaskPool extends EventEmitter {
      * @param concurrency The maximum concurrency tasks number.
      */
     setConcurrency(concurrency: number): void;
+    /**
+     * Gets execution errors of last time.
+     */
+    getErrors(): (Error | undefined)[];
+    /**
+     * Get task instance by it's id.
+     */
+    getTask(id: number): Task | null;
     private runTask;
     private nextTask;
     private run;
     private checkRunningState;
+    private handleError;
 }
 export {};

lib/pool.js

@@ -9,6 +9,7 @@ class TaskPool extends events_1.EventEmitter {
         this.DEFAULT_CONCURRENCY = 30;
         this.tasks = [];
         this.resolutions = [];
+        this.errors = [];
         this.isRunning = false;
         this.queue = [];
         this.running = new Set();
@@ -28,6 +29,12 @@ class TaskPool extends events_1.EventEmitter {
         if (typeof this.concurrency !== 'number' || this.concurrency < 0) {
             throw new TypeError('Invalid concurrency number');
         }
+        if (typeof options?.throwsError === 'boolean') {
+            this.throwsError = options.throwsError;
+        }
+        else {
+            this.throwsError = true;
+        }
         this.on('done', this.nextTask);
     }
     /**
@@ -36,19 +43,36 @@ class TaskPool extends events_1.EventEmitter {
      */
     addTask(task) {
         if (task instanceof task_1.Task) {
-            this.tasks.push(task);
+            const length = this.tasks.push(task);
+            return length - 1;
         }
-        else if (task instanceof Array) {
-            task.forEach((t) => {
-                if (!(t instanceof task_1.Task)) {
-                    throw new TypeError('Invalid task');
-                }
-                this.tasks.push(t);
-            });
+        // throw error if params is not a task or a tasks array.
+        throw new TypeError('Invalid task(s)');
+    }
+    /**
+     * Add tasks array into pool.
+     * @param tasks Task instances array.
+     */
+    addTasks(tasks) {
+        let taskArr;
+        if (tasks instanceof Array) {
+            taskArr = tasks;
+        }
+        else if (tasks instanceof task_1.Task) {
+            taskArr = [tasks];
         }
         else {
-            throw new TypeError('Invalid task');
+            throw new TypeError('Invalid task(s)');
         }
+        const ids = [];
+        taskArr.forEach((t) => {
+            if (!(t instanceof task_1.Task)) {
+                throw new TypeError('Invalid task');
+            }
+            const length = this.tasks.push(t);
+            ids.push(length - 1);
+        });
+        return ids;
     }
     /**
      * Execute all tasks in the pool.
@@ -71,19 +95,37 @@ class TaskPool extends events_1.EventEmitter {
         }
         this.concurrency = concurrency;
     }
+    /**
+     * Gets execution errors of last time.
+     */
+    getErrors() {
+        return [...this.errors];
+    }
+    /**
+     * Get task instance by it's id.
+     */
+    getTask(id) {
+        return id in this.tasks ? this.tasks[id] : null;
+    }
     runTask(index) {
         if (index >= this.tasks.length) {
             throw new Error('Invalid task');
         }
         const task = this.tasks[index];
         this.running.add(index);
-        Promise.resolve(task.exec()).then((res) => {
-            this.running.delete(index);
-            this.resolutions[index] = res;
-            this.emit('done');
-        }, (err) => {
-            this.emit('error', err);
-        });
+        try {
+            Promise.resolve(task.exec()).then((res) => {
+                this.running.delete(index);
+                this.resolutions[index] = res;
+                this.emit('done');
+            }, (err) => {
+                this.running.delete(index);
+                this.handleError(err, index);
+            });
+        }
+        catch (err) {
+            this.handleError(err, index);
+        }
     }
     nextTask() {
         const next = this.queue.shift();
@@ -100,9 +142,13 @@ class TaskPool extends events_1.EventEmitter {
         this.running.clear();
         this.queue = [];
         this.isRunning = true;
+        // clear last resolutions and errors
+        this.resolutions = [];
+        this.errors = [];
         // eslint-disable-next-line no-unused-vars
         return new Promise((resolve, reject) => {
             this.on('error', (err) => {
+                this.isRunning = false;
                 reject(err);
             });
             this.on('completed', () => {
@@ -124,5 +170,16 @@ class TaskPool extends events_1.EventEmitter {
             throw new Error('Task pool is executing');
         }
     }
+    handleError(err, index) {
+        if (this.throwsError) {
+            this.queue = [];
+            this.emit('error', err);
+        }
+        else {
+            this.running.delete(index);
+            this.errors[index] = err;
+            this.emit('done');
+        }
+    }
 }
 exports.TaskPool = TaskPool;

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@antmind/task-pool",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "A simple Node.js functional tasks pool implementation, supported both synchronous and asynchronous functions.",
   "main": "./lib/index.js",
   "scripts": {