fix(*): fix process

Author: neki-dev

README.md

@@ -41,10 +41,11 @@ const pathfinding = new Pathfinding(
 
 - `config` - _Pathfinding configuration_
 
-| Prop           | Description            | Default |
-| -------------- | ---------------------- | ------- |
-| loopRate       | Finding next task rate | 200 ms  |
-| resourceLimits | Worker resource limits | -       |
+| Prop           | Description                                                                      | Default |
+| -------------- | -------------------------------------------------------------------------------- | ------- |
+| loopRate       | Pause before executing the next task after all previous ones have been completed | 100 ms  |
+| maxStackSize   | Max recursive depth to handle task in one tick                                   | 128     |
+| resourceLimits | Worker resource limits                                                           | -       |
 
 ### ⚡️ Terminate worker thread
 

dist/index.js

@@ -1,10 +1,20 @@
 import type { ResourceLimits } from 'worker_threads';
 export type PathfindingConfig = {
     /**
-     * Finding next task rate
-     * Default: 200 ms
+     * Use taskFindingRate instead
+     * @deprecated
      */
     loopRate?: number;
+    /**
+     * Pause before executing the next task after all previous ones have been completed
+     * Default: 100 ms
+     */
+    taskFindingRate?: number;
+    /**
+     * Max recursive depth to handle task in one tick
+     * Default: 128
+     */
+    maxStackSize?: number;
     /**
      * Worker resource limits
      */

dist/pathfinding/types.d.ts

@@ -1,3 +1,8 @@
 export type PathfindingProcessConfig = {
+    /**
+     * @deprecated
+     */
     loopRate?: number;
+    taskFindingRate?: number;
+    maxStackSize?: number;
 };

dist/process/types.d.ts

@@ -1,7 +1,7 @@
 {
   "name": "pathfinding-worker",
   "description": "Fast node.js pathfinding on workers for grid-based games",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "keywords": [
     "astar",
     "dijkstra",

package.json

@@ -2,11 +2,23 @@ import type { ResourceLimits } from 'worker_threads';
 
 export type PathfindingConfig = {
   /**
-   * Finding next task rate
-   * Default: 200 ms
+   * Use taskFindingRate instead
+   * @deprecated
    */
   loopRate?: number;
 
+  /**
+   * Pause before executing the next task after all previous ones have been completed
+   * Default: 100 ms
+   */
+  taskFindingRate?: number;
+
+  /**
+   * Max recursive depth to handle task in one tick
+   * Default: 128
+   */
+  maxStackSize?: number;
+
   /**
    * Worker resource limits
    */

src/pathfinding/types.ts

@@ -1,7 +1,7 @@
 /**
  * @internal
  */
-export const PATHFINDING_PROCESS_LOOP_RATE = 100;
+export const PATHFINDING_PROCESS_TASK_FINDING_RATE = 100;
 
 /**
  * @internal

src/process/const.ts

@@ -1,5 +1,5 @@
 import {
-  PATHFINDING_PROCESS_LOOP_RATE,
+  PATHFINDING_PROCESS_TASK_FINDING_RATE,
   PATHFINDING_PROCESS_NEXT_DIRECTIINS_DIAGONAL,
   PATHFINDING_PROCESS_NEXT_DIRECTIINS_STRAIGHT,
   PATHFINDING_PROCESS_TASK_HANDLING_MAX_STACK_SIZE,
@@ -21,27 +21,27 @@ export class PathfindingProcess {
 
   private queue: PathfindingTask[] = [];
 
-  private readonly timer: NodeJS.Timeout;
+  private timer: NodeJS.Timeout | null = null;
 
-  private processing: boolean = false;
+  private readonly maxStackSize: number;
 
-  constructor({
-    loopRate = PATHFINDING_PROCESS_LOOP_RATE,
-  }: PathfindingProcessConfig) {
-    this.timer = setInterval(() => {
-      try {
-        if (!this.processing) {
-          this.processing = true;
-          this.handleTask();
-        }
-      } catch (error) {
-        console.error('Pathfinding process error:', error);
-      }
-    }, loopRate);
+  private readonly taskFindingRate: number;
+
+  constructor({ taskFindingRate, maxStackSize, loopRate }: PathfindingProcessConfig) {
+    this.taskFindingRate = (taskFindingRate ?? loopRate) ?? PATHFINDING_PROCESS_TASK_FINDING_RATE;
+    this.maxStackSize = maxStackSize ?? PATHFINDING_PROCESS_TASK_HANDLING_MAX_STACK_SIZE;
+
+    try {
+      this.handleTask();
+    } catch (error) {
+      console.error('Pathfinding process initialize error:', error);
+    }
   }
 
   public destroy(): void {
-    clearTimeout(this.timer);
+    if (this.timer) {
+      clearTimeout(this.timer);
+    }
   }
 
   public createTask(task: PathfindingTask): void {
@@ -105,12 +105,15 @@ export class PathfindingProcess {
   private handleTask(stackSize: number = 0): void {
     const task = this.queue[0];
     if (!task) {
-      this.processing = false;
+      this.timer = setTimeout(() => {
+        this.timer = null;
+        this.handleTask();
+      }, this.taskFindingRate);
       return;
     }
 
     const next = () => {
-      if (stackSize >= PATHFINDING_PROCESS_TASK_HANDLING_MAX_STACK_SIZE) {
+      if (stackSize >= this.maxStackSize) {
         setTimeout(() => {
           this.handleTask();
         });
@@ -122,7 +125,7 @@ export class PathfindingProcess {
     const complete = (result: PathfindingTaskResultRaw) => {
       this.queue.shift();
       task.complete(result);
-      this.processing = false;
+      next();
     };
 
     try {

src/process/index.ts

@@ -1,3 +1,8 @@
 export type PathfindingProcessConfig = {
+  /**
+   * @deprecated
+   */
   loopRate?: number;
+  taskFindingRate?: number;
+  maxStackSize?: number;
 };