fix(*): fix queue

Author: neki-dev

README.md

@@ -41,11 +41,10 @@ const pathfinding = new Pathfinding(
 
 - `config` - _Pathfinding configuration_
 
-| Prop            | Description            | Default |
-| --------------- | ---------------------- | ------- |
-| loopRate        | Finding next task rate | 100 ms  |
-| taskProcessRate | Processing task rate   | 0 ms    |
-| resourceLimits  | Worker resource limits | -       |
+| Prop           | Description            | Default |
+| -------------- | ---------------------- | ------- |
+| loopRate       | Finding next task rate | 200 ms  |
+| resourceLimits | Worker resource limits | -       |
 
 ### ⚡️ Terminate worker thread
 

dist/index.js

@@ -12,7 +12,7 @@ export declare class Pathfinding {
      *
      * @param config - Pathfinding configuration
      */
-    constructor({ loopRate, taskProcessRate, resourceLimits }?: PathfindingConfig);
+    constructor({ loopRate, resourceLimits }?: PathfindingConfig);
     /**
      * Terminate worker thread.
      */

dist/pathfinding/index.d.ts

@@ -2,14 +2,9 @@ import type { ResourceLimits } from 'worker_threads';
 export type PathfindingConfig = {
     /**
      * Finding next task rate
-     * Default: 100 ms
+     * Default: 200 ms
      */
     loopRate?: number;
-    /**
-     * Processing task rate
-     * Default: 0 ms
-     */
-    taskProcessRate?: number;
     /**
      * Worker resource limits
      */

dist/pathfinding/types.d.ts

@@ -1,4 +1,3 @@
 export type PathfindingProcessConfig = {
     loopRate?: number;
-    taskProcessRate?: 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.5.2",
+  "version": "2.6.0",
   "keywords": [
     "astar",
     "dijkstra",
@@ -26,7 +26,7 @@
     "build": "yarn build:worker && yarn build:entrypoint",
     "build:worker": "webpack --config ./webpack/worker.config.js --mode production",
     "build:entrypoint": "webpack --config ./webpack/entrypoint.config.js --mode production",
-    "test": "jest",
+    "test": "yarn build && jest",
     "lint": "eslint \"./src/**/*.ts\" --fix"
   },
   "dependencies": {

package.json

@@ -20,11 +20,11 @@ export class Pathfinding {
    *
    * @param config - Pathfinding configuration
    */
-  constructor({ loopRate, taskProcessRate, resourceLimits }: PathfindingConfig = {}) {
+  constructor({ loopRate, resourceLimits }: PathfindingConfig = {}) {
     this.worker = new Worker(INLINE_WORKER, {
       name: 'pathfinding',
       eval: true,
-      workerData: { loopRate, taskProcessRate },
+      workerData: { loopRate },
       resourceLimits,
     });
 

src/pathfinding/index.ts

@@ -3,16 +3,10 @@ import type { ResourceLimits } from 'worker_threads';
 export type PathfindingConfig = {
   /**
    * Finding next task rate
-   * Default: 100 ms
+   * Default: 200 ms
    */
   loopRate?: number;
 
-  /**
-   * Processing task rate
-   * Default: 0 ms
-   */
-  taskProcessRate?: number;
-
   /**
    * Worker resource limits
    */

src/pathfinding/types.ts

@@ -6,7 +6,7 @@ export const PATHFINDING_PROCESS_LOOP_RATE = 100;
 /**
  * @internal
  */
-export const PATHFINDING_PROCESS_TASK_PROCESS_RATE = 0;
+export const PATHFINDING_PROCESS_TASK_HANDLING_MAX_STACK_SIZE = 128;
 
 /**
  * @internal

src/process/const.ts

@@ -2,7 +2,7 @@ import {
   PATHFINDING_PROCESS_LOOP_RATE,
   PATHFINDING_PROCESS_NEXT_DIRECTIINS_DIAGONAL,
   PATHFINDING_PROCESS_NEXT_DIRECTIINS_STRAIGHT,
-  PATHFINDING_PROCESS_TASK_PROCESS_RATE,
+  PATHFINDING_PROCESS_TASK_HANDLING_MAX_STACK_SIZE,
 } from './const';
 
 import type { PathfindingProcessConfig } from './types';
@@ -21,26 +21,27 @@ export class PathfindingProcess {
 
   private queue: PathfindingTask[] = [];
 
-  private timer: NodeJS.Timeout | null = null;
+  private readonly timer: NodeJS.Timeout;
 
-  private readonly taskProcessRate: number;
-
-  private readonly loopRate: number;
+  private processing: boolean = false;
 
   constructor({
-    taskProcessRate = PATHFINDING_PROCESS_TASK_PROCESS_RATE,
     loopRate = PATHFINDING_PROCESS_LOOP_RATE,
   }: PathfindingProcessConfig) {
-    this.taskProcessRate = taskProcessRate;
-    this.loopRate = loopRate;
-
-    this.handleTask();
+    this.timer = setInterval(() => {
+      try {
+        if (!this.processing) {
+          this.processing = true;
+          this.handleTask();
+        }
+      } catch (error) {
+        console.error('Pathfinding process error:', error);
+      }
+    }, loopRate);
   }
 
   public destroy(): void {
-    if (this.timer) {
-      clearTimeout(this.timer);
-    }
+    clearTimeout(this.timer);
   }
 
   public createTask(task: PathfindingTask): void {
@@ -101,76 +102,77 @@ export class PathfindingProcess {
     grid[position.y][position.x] = state;
   }
 
-  private handleTask(): void {
+  private handleTask(stackSize: number = 0): void {
     const task = this.queue[0];
     if (!task) {
-      this.timer = setTimeout(() => {
-        this.timer = null;
-        this.handleTask();
-      }, this.loopRate);
+      this.processing = false;
       return;
     }
 
     const next = () => {
-      setTimeout(() => {
-        this.handleTask();
-      }, this.taskProcessRate);
+      if (stackSize >= PATHFINDING_PROCESS_TASK_HANDLING_MAX_STACK_SIZE) {
+        setTimeout(() => {
+          this.handleTask();
+        });
+      } else {
+        this.handleTask(stackSize + 1);
+      }
     };
 
     const complete = (result: PathfindingTaskResultRaw) => {
       this.queue.shift();
       task.complete(result);
+      this.processing = false;
     };
 
     try {
       const currentNode = task.takeLastNode();
-      if (currentNode) {
-        if (task.isVisited(currentNode.position)) {
-          next();
+      if (!currentNode) {
+        return complete({
+          path: null,
+          weight: Infinity,
+        });
+      }
+
+      if (task.isVisited(currentNode.position)) {
+        return next();
+      }
+
+      task.markVisited(currentNode.position);
+
+      if (
+        currentNode.position.x === task.to.x &&
+        currentNode.position.y === task.to.y
+      ) {
+        return complete(currentNode.compute());
+      }
+
+      this.getNextDirections(task, currentNode).forEach((offset) => {
+        const position = {
+          x: currentNode.position.x + offset.x,
+          y: currentNode.position.y + offset.y,
+        };
+
+        if (task.isVisited(position)) {
           return;
         }
 
-        task.markVisited(currentNode.position);
+        const weights = this.weights.get(task.idLayer) ?? [];
+        const nextWeight = task.getNextWeight(currentNode, offset, weights);
+        const nextNode = task.pickNode(position);
 
-        if (
-          currentNode.position.x === task.to.x &&
-          currentNode.position.y === task.to.y
-        ) {
-          complete(currentNode.compute());
+        if (nextNode) {
+          if (nextWeight < nextNode.getWeight()) {
+            task.rewriteNode(currentNode, nextNode, nextWeight);
+          }
         } else {
-          this.getNextDirections(task, currentNode).forEach((offset) => {
-            const position = {
-              x: currentNode.position.x + offset.x,
-              y: currentNode.position.y + offset.y,
-            };
-
-            if (task.isVisited(position)) {
-              return;
-            }
-
-            const weights = this.weights.get(task.idLayer) ?? [];
-            const nextWeight = task.getNextWeight(currentNode, offset, weights);
-            const nextNode = task.pickNode(position);
-
-            if (nextNode) {
-              if (nextWeight < nextNode.getWeight()) {
-                task.rewriteNode(currentNode, nextNode, nextWeight);
-              }
-            } else {
-              task.addNode(currentNode, position, nextWeight);
-            }
-          });
+          task.addNode(currentNode, position, nextWeight);
         }
-      } else {
-        complete({
-          path: null,
-          weight: Infinity,
-        });
-      }
+      });
 
       next();
     } catch (error) {
-      console.error('Pathfinding process error:', error);
+      console.error('Pathfinding handle task error:', error);
       complete({
         path: null,
         weight: Infinity,