2.1.15

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/taskbuffer",
-  "version": "2.1.11",
+  "version": "2.1.15",
   "private": false,
   "description": "flexible task management. TypeScript ready!",
   "main": "dist_ts/index.js",
@@ -27,20 +27,20 @@
   },
   "homepage": "https://gitlab.com/pushrocks/taskbuffer#readme",
   "dependencies": {
-    "@pushrocks/lik": "^4.0.17",
-    "@pushrocks/smartdelay": "^2.0.10",
-    "@pushrocks/smartlog": "^2.0.36",
-    "@pushrocks/smartpromise": "^3.0.6",
-    "@pushrocks/smartrx": "^2.0.18",
-    "@pushrocks/smarttime": "^3.0.31",
-    "@types/cron": "^1.7.2"
+    "@pushrocks/lik": "^5.0.0",
+    "@pushrocks/smartdelay": "^2.0.13",
+    "@pushrocks/smartlog": "^2.0.44",
+    "@pushrocks/smartpromise": "^3.1.6",
+    "@pushrocks/smartrx": "^2.0.19",
+    "@pushrocks/smarttime": "^3.0.43",
+    "@types/cron": "^1.7.3"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.25",
-    "@gitzone/tsbundle": "^1.0.78",
-    "@gitzone/tstest": "^1.0.44",
-    "@pushrocks/tapbundle": "^3.2.9",
-    "@types/node": "^14.6.4",
+    "@gitzone/tsbuild": "^2.1.28",
+    "@gitzone/tsbundle": "^1.0.88",
+    "@gitzone/tstest": "^1.0.60",
+    "@pushrocks/tapbundle": "^3.2.14",
+    "@types/node": "^16.11.7",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0"
   },

test/test.4.taskmanager.ts

@@ -1,47 +0,0 @@
-import { expect, tap } from '@pushrocks/tapbundle';
-import taskbuffer = require('../ts/index');
-
-import * as smartpromise from '@pushrocks/smartpromise';
-import * as smartdelay from '@pushrocks/smartdelay';
-
-let myTaskManager: taskbuffer.TaskManager;
-let taskRunCounter = 0;
-const taskDone = smartpromise.defer();
-
-tap.test('should create an instance of TaskManager', async () => {
-  myTaskManager = new taskbuffer.TaskManager();
-  expect(myTaskManager).to.be.instanceof(taskbuffer.TaskManager);
-});
-
-tap.test('should run the task as expected', async () => {
-  let referenceBoolean = false;
-  myTaskManager.addTask(
-    new taskbuffer.Task({
-      name: 'myTask',
-      taskFunction: async () => {
-        console.log('Task executed!');
-        referenceBoolean = true;
-        taskRunCounter++;
-        if (taskRunCounter === 10) {
-          taskDone.resolve();
-        }
-      },
-    })
-  );
-  myTaskManager.start();
-  await myTaskManager.triggerTaskByName('myTask');
-  // tslint:disable-next-line:no-unused-expression
-  expect(referenceBoolean).to.be.true;
-});
-
-tap.test('should schedule task', async () => {
-  myTaskManager.scheduleTaskByName('myTask', '* * * * * *');
-  await taskDone.promise;
-  myTaskManager.descheduleTaskByName('myTask');
-});
-
-tap.test('should stop the taskmanager', async () => {
-  myTaskManager.stop();
-});
-
-tap.start();

test/test.8.bufferedrun.ts

@@ -0,0 +1,52 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+
+import * as taskbuffer from '../ts';
+
+let counter1 = 0;
+let counter2 = 0;
+let counter3 = 0;
+
+tap.test('should run buffered', async (tools) => {
+  const task = new taskbuffer.Task({
+    name: 'a buffered task',
+    taskFunction: async () => {
+      counter1++;
+      await tools.delayFor(2000);
+      console.log(`task 1 ran ${counter1} times`);
+    },
+    buffered: true,
+    bufferMax: 1,
+    afterTask: () => {
+      return task2;
+    }
+  });
+  const task2 = new taskbuffer.Task({
+    name: 'a buffered task',
+    taskFunction: async () => {
+      counter2++;
+      await tools.delayFor(2000);
+      console.log(`task2 ran ${counter2} times`);
+    },
+    buffered: true,
+    bufferMax: 1,
+    afterTask: () => {
+      return task3;
+    }
+  });
+  const task3 = new taskbuffer.Task({
+    name: 'a buffered task',
+    taskFunction: async () => {
+      counter3++;
+      await tools.delayFor(2000);
+      console.log(`task3 ran ${counter3} times`);
+    },
+    buffered: true,
+    bufferMax: 1
+  });
+  while(counter1 < 10) {
+    await tools.delayFor(5000);
+    task.trigger();
+  }
+})
+
+tap.start();

ts/taskbuffer.classes.bufferrunner.ts

@@ -4,36 +4,33 @@ export class BufferRunner {
   public task: Task;
   // initialze by default
   public bufferCounter: number = 0;
-  public running: boolean = false;
   constructor(taskArg: Task) {
     this.task = taskArg;
   }
 
-  public trigger(x): Promise<any> {
+  public trigger(x: any): Promise<any> {
     if (!(this.bufferCounter >= this.task.bufferMax)) {
       this.bufferCounter++;
     }
     const returnPromise: Promise<any> = this.task.cycleCounter.getPromiseForCycle(
       this.bufferCounter + 1
     );
-    if (!this.running) {
+    if (!this.task.running) {
       this._run(x);
     }
     return returnPromise;
   }
 
-  private _run(x) {
-    const recursiveBufferRunner = (x) => {
+  private _run(x: any) {
+    const recursiveBufferRunner = (x: any) => {
       if (this.bufferCounter >= 0) {
-        this.running = true;
         this.task.running = true;
         Task.runTask(this.task, { x: x }).then((x) => {
-          this.bufferCounter--;
+          this.bufferCounter--; // this.bufferCounter drops below 0, the recursion stops.
           this.task.cycleCounter.informOfCycle(x);
           recursiveBufferRunner(x);
         });
       } else {
-        this.running = false;
         this.task.running = false;
       }
     };

ts/taskbuffer.classes.cyclecounter.ts

@@ -21,7 +21,7 @@ export class CycleCounter {
     this.cycleObjectArray.push(cycleObject);
     return done.promise;
   }
-  public informOfCycle(x) {
+  public informOfCycle(x: any) {
     const newCycleObjectArray: ICycleObject[] = [];
     this.cycleObjectArray.forEach((cycleObjectArg) => {
       cycleObjectArg.cycleCounter--;

ts/taskbuffer.classes.task.ts

@@ -56,7 +56,7 @@ export class Task {
 
   public static runTask = async (
     taskArg: Task | TPreOrAfterTaskFunction,
-    optionsArg: { x?; touchedTasksArray?: Task[] }
+    optionsArg: { x?: any; touchedTasksArray?: Task[] }
   ) => {
     const taskToRun = Task.extractTask(taskArg);
     const done = plugins.smartpromise.defer();
@@ -190,7 +190,7 @@ export class Task {
   /**
    * trigger the task. Will trigger buffered if this.buffered is true
    */
-  public trigger(x?): Promise<any> {
+  public trigger(x?: any): Promise<any> {
     if (this.buffered) {
       return this.triggerBuffered(x);
     } else {
@@ -202,15 +202,15 @@ export class Task {
    * trigger task unbuffered.
    * will actually run the task, not considering any buffered limits.
    */
-  public triggerUnBuffered(x?): Promise<any> {
+  public triggerUnBuffered(x?: any): Promise<any> {
     return Task.runTask(this, { x: x });
   }
 
   /**
    * trigger task buffered.
-   * will simply call task.trigger(), which respects buffering by default
+   * note: .trigger() also calls this function
    */
-  public triggerBuffered(x?): Promise<any> {
+  public triggerBuffered(x?: any): Promise<any> {
     return this.bufferRunner.trigger(x);
   }
 

ts/taskbuffer.classes.taskchain.ts

@@ -25,7 +25,7 @@ export class Taskchain extends Task {
           // this is the function that gets executed when TaskChain is triggered
           const done = plugins.smartpromise.defer(); // this is the starting Deferred object
           let taskCounter = 0; // counter for iterating async over the taskArray
-          const iterateTasks = (x) => {
+          const iterateTasks = (x: any) => {
             if (typeof this.taskArray[taskCounter] !== 'undefined') {
               console.log(this.name + ' running: Task' + this.taskArray[taskCounter].name);
               this.taskArray[taskCounter].trigger(x).then((x) => {

ts/taskbuffer.classes.taskmanager.ts

@@ -20,8 +20,8 @@ export class TaskManager {
    * checks if a task is already present
    * @param taskNameArg
    */
-  public getTaskByName(taskNameArg): Task {
-    return this.taskMap.find((itemArg) => {
+  public getTaskByName(taskNameArg: string): Task {
+    return this.taskMap.findSync((itemArg) => {
       return itemArg.name === taskNameArg;
     });
   }