clever-queue 0.1.1 → 0.2.0

package/examples/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "clever-queue_examples",
+  "scripts": {
+    "build": "npx tsc -p src/ --declaration",
+    "build:watch": "npx tsc -p src/ -w",
+    "prestart": "npx npm run build",
+    "start": "node dist/index.js",
+    "debug": "node --nolazy --inspect-brk=9229 dist/index.js"
+  },
+  "author": "Olivier GROSJEANNE",
+  "license": "ISC",
+  "dependencies": {
+    "clever-queue": "../dist"
+  }
+}

package/examples/src/demo_1E_1Q_1R_4T.ts

@@ -0,0 +1,37 @@
+import { animations, myAsyncTaskToExecute } from "./helpers";
+import * as cleverQueue from "clever-queue";
+
+async function run(): Promise<void> {
+  
+  const engine = cleverQueue.createEngine({ autostart: false });
+  const queueA = engine.createQueue();
+
+
+  const tasks: cleverQueue.tasks.Task[] = [];
+  const promiseList: Promise<unknown>[] = [];
+
+  const tasksList: { id: string; timeout: number; queue: cleverQueue.queues.Queue }[] = [
+    { id: "task A1", timeout: 2500, queue: queueA },
+    { id: "task A2", timeout: 2500, queue: queueA },
+    { id: "task A3", timeout: 2500, queue: queueA },
+    { id: "task A4", timeout: 2500, queue: queueA },
+  ];
+
+  for (const taskInfo of tasksList) {
+    const task = engine.createTask(() => myAsyncTaskToExecute(taskInfo.id, taskInfo.timeout), { id: taskInfo.id });
+    tasks.push(task);
+    promiseList.push(taskInfo.queue.enqueue(task));
+  }
+
+  const anim = new animations.Animation(engine, tasks, "./documentation/" + __filename.slice(__dirname.length + 1, -3) + ".svg");
+
+  await anim.start()
+  engine.start();
+  await Promise.all(promiseList);
+  engine.stop();
+  await anim.stop();
+}
+
+(async () => {
+  await run();
+})();

package/examples/src/demo_1E_1Q_2R_4T.ts

@@ -0,0 +1,36 @@
+import { animations, myAsyncTaskToExecute } from "./helpers";
+import * as cleverQueue from "clever-queue";
+
+async function run(): Promise<void> {
+  const engine = cleverQueue.createEngine({ autostart: false });
+  engine.createRunner({ priority: cleverQueue.queues.Priorities.BestEffort });
+  const queueA = engine.createQueue();
+
+  const tasks: cleverQueue.tasks.Task[] = [];
+  const promiseList: Promise<unknown>[] = [];
+
+  const tasksList: { id: string; timeout: number; queue: cleverQueue.queues.Queue }[] = [
+    { id: "task A1", timeout: 2500, queue: queueA },
+    { id: "task A2", timeout: 2500, queue: queueA },
+    { id: "task A3", timeout: 2500, queue: queueA },
+    { id: "task A4", timeout: 2500, queue: queueA },
+  ];
+
+  for (const taskInfo of tasksList) {
+    const task = engine.createTask(() => myAsyncTaskToExecute(taskInfo.id, taskInfo.timeout), { id: taskInfo.id });
+    tasks.push(task);
+    promiseList.push(taskInfo.queue.enqueue(task));
+  }
+
+  const anim = new animations.Animation(engine, tasks, "./documentation/" + __filename.slice(__dirname.length + 1, -3) + ".svg");
+
+  await anim.start()
+  engine.start();
+  await Promise.all(promiseList);
+  engine.stop();
+  await anim.stop();
+}
+
+(async () => {
+  await run();
+})();

package/examples/src/demo_1E_2Q_1R_8T.ts

@@ -0,0 +1,40 @@
+import { animations, myAsyncTaskToExecute } from "./helpers";
+import * as cleverQueue from "clever-queue";
+
+async function run(): Promise<void> {
+  const engine = cleverQueue.createEngine({ autostart: false });
+  const queueA = engine.createQueue();
+  const queueB = engine.createQueue();
+
+  const tasks: cleverQueue.tasks.Task[] = [];
+  const promiseList: Promise<unknown>[] = [];
+
+  const tasksList: { id: string; timeout: number; queue: cleverQueue.queues.Queue }[] = [
+    { id: "task A1", timeout: 2500, queue: queueA },
+    { id: "task A2", timeout: 2500, queue: queueA },
+    { id: "task A3", timeout: 2500, queue: queueA },
+    { id: "task A4", timeout: 2500, queue: queueA },
+    { id: "task B1", timeout: 2500, queue: queueB },
+    { id: "task B2", timeout: 2500, queue: queueB },
+    { id: "task B3", timeout: 2500, queue: queueB },
+    { id: "task B4", timeout: 2500, queue: queueB },
+  ];
+
+  for (const taskInfo of tasksList) {
+    const task = engine.createTask(() => myAsyncTaskToExecute(taskInfo.id, taskInfo.timeout), { id: taskInfo.id });
+    tasks.push(task);
+    promiseList.push(taskInfo.queue.enqueue(task));
+  }
+
+  const anim = new animations.Animation(engine, tasks, "./documentation/" + __filename.slice(__dirname.length + 1, -3) + ".svg");
+
+  await anim.start()
+  engine.start();
+  await Promise.all(promiseList);
+  engine.stop();
+  await anim.stop();
+}
+
+(async () => {
+  await run();
+})();

package/examples/src/example00.ts

@@ -0,0 +1,16 @@
+import * as cleverQueue from "clever-queue"; // import the library - no dependancies
+
+const engine = cleverQueue.createEngine(); // create and start (by default) engine with a single best effort runner (by default)
+const queue = engine.createQueue(); // create your first queue, with standard priority (by default) and default weight (by default) 
+
+const myAsyncTaskToExecute: cleverQueue.tasks.FunctionToExecute = async function (message: string, timeout: number) {
+    // do your stuff here - In this case, just wait for the timeout and return the message
+    await new Promise((resolve) => setTimeout(resolve, timeout));
+    return message;
+};
+
+(async () => {
+    const result = await queue.createTaskAndEnqueue(() => myAsyncTaskToExecute("myValue", 1000));
+    console.log(result);
+    engine.stop(); // stop the engine when you want
+})();

package/examples/src/helpers/animations.ts

@@ -0,0 +1,295 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+import * as svg from "./svg";
+import * as cleverQueue from "clever-queue";
+
+const WIDTH = 800;
+const HEIGHT = 800;
+const RADIUS = 20;
+
+const TASK_WIDTH = 80;
+const TASK_HEIGHT = 80;
+const TASK_MARGIN = 10;
+
+const TASKS_TO_FIT_IN_QUEUE = 4;
+const QUEUE_WIDTH = TASK_WIDTH + 2 * TASK_MARGIN;;
+const QUEUE_HEIGHT = TASK_HEIGHT * TASKS_TO_FIT_IN_QUEUE + (TASKS_TO_FIT_IN_QUEUE - 1) * (TASK_MARGIN);
+const QUEUE_Y = 100;
+
+const RUNNER_WIDTH = TASK_WIDTH + 2 * TASK_MARGIN;
+const RUNNER_HEIGHT = TASK_HEIGHT + 2 * TASK_MARGIN;
+const RUNNER_Y = QUEUE_Y + QUEUE_HEIGHT + 2 * TASK_HEIGHT;
+
+const STARTINGZONE_Y = 10;
+const RUNNEDZONE_Y = RUNNER_Y + RUNNER_HEIGHT + 2 * TASK_HEIGHT;
+
+const INTERVAL = 1;
+
+const svgFile: svg.SvgFile = {
+  svg: {
+    $xmlns: "http://www.w3.org/2000/svg",
+    $width: WIDTH,
+    $height: HEIGHT,
+    g: [
+      {
+        rect: [
+          {
+            $x: 10,
+            $y: 10,
+            $width: 10,
+            $height: 10,
+            // $fill: "lightgreen",
+          },
+        ],
+        animateMotion: [
+          {
+            $id: "start",
+            $begin: "stop.end;0",
+            $dur: 2,
+            $path: "M" + WIDTH / 2 + ",-" + HEIGHT,
+          },
+        ],
+      },
+    ],
+  },
+};
+
+class Animation {
+  engine: cleverQueue.engine.Engine;
+  tasks: cleverQueue.tasks.Task[];
+  interval: NodeJS.Timeout | undefined = undefined;
+  tick: number = 0;
+  svgFileOutputPath: string;
+
+  constructor(cqEngine: cleverQueue.engine.Engine, tasks: cleverQueue.tasks.Task[], svgFileOutputPath: string) {
+    this.engine = cqEngine;
+    this.tasks = tasks;
+    this.drawQueues(this.engine.queues);
+    this.drawRunners(this.engine.runners);
+    this.drawTasks(tasks);
+    this.svgFileOutputPath = path.resolve(process.cwd(), svgFileOutputPath);
+  }
+
+  async start(): Promise<void> {
+    this.interval = setInterval(() => {
+      console.log(JSON.stringify(this.engine.statistics(), null, 2));
+      this.tick += INTERVAL;
+      this.animateMotionTasks(this.tasks);
+    }, INTERVAL * 1000);
+    await new Promise((resolve) => setTimeout(resolve, 3000));
+  }
+
+  async stop(): Promise<void> {
+    await new Promise((resolve) => setTimeout(resolve, 3000));
+    if (this.interval) this.interval.close();
+
+    svgFile.svg.g?.push({
+      rect: [
+        {
+          $x: 10,
+          $y: 10,
+          $width: 10,
+          $height: 10,
+          // $fill: "lightgreen",
+        },
+      ],
+      animateMotion: [
+        {
+          $id: "stop",
+          $begin: "start.end  + " + this.tick.toString() + "s",
+          $dur: 2,
+          $path: "M" + WIDTH / 2 + ",-" + HEIGHT,
+        },
+      ],
+    });
+    const builder = new svg.XMLBuilder(svg.options);
+    const xmlDataString = builder.build(svgFile);
+
+    fs.writeFileSync(this.svgFileOutputPath, xmlDataString);
+    console.log(xmlDataString);
+  }
+
+  drawQueues(queues: cleverQueue.queues.Queue[]): void {
+    const queueCount = queues.length;
+    const freeSpace = WIDTH - queueCount * RUNNER_WIDTH;
+    const spacesCount = queueCount + 1;
+    const spaceWidth = freeSpace / spacesCount;
+    for (let q = 0; q < queues.length; q++) {
+      const queue = queues[q];
+      queue.tags["x"] = (q + 1) * spaceWidth + q * QUEUE_WIDTH;
+      queue.tags["y"] = QUEUE_Y;
+      queue.tags["width"] = QUEUE_WIDTH;
+      queue.tags["height"] = QUEUE_HEIGHT;
+      svgFile.svg.g?.push({
+        $id: queue.options.id ?? "",
+        g: [
+          {
+            rect: [
+              {
+                $x: queue.tags["x"],
+                $y: queue.tags["y"],
+                $width: queue.tags["width"],
+                $height: queue.tags["height"],
+                $rx: RADIUS,
+                $ry: RADIUS,
+                $fill: "lightblue",
+                $stroke: "blue",
+                "$stroke-width": 5,
+              },
+            ],
+          },
+        ],
+      });
+    }
+  }
+
+  drawRunners(runners: cleverQueue.runners.Runner[]): void {
+    const runnersCount = runners.length;
+    const freeSpace = WIDTH - runnersCount * RUNNER_WIDTH;
+    const spacesCount = runners.length + 1;
+    const spaceWidth = freeSpace / spacesCount;
+    // console.log(runnersCount, freeSpace, spacesCount, spaceWidth);
+    for (let r = 0; r < runners.length; r++) {
+      const runner = runners[r];
+      runner.tags["x"] = (r + 1) * spaceWidth + r * RUNNER_WIDTH;
+      runner.tags["y"] = RUNNER_Y;
+      runner.tags["width"] = RUNNER_WIDTH;
+      runner.tags["height"] = RUNNER_HEIGHT;
+      svgFile.svg.g?.push({
+        $id: runner.options.id ?? "",
+        g: [
+          {
+            rect: [
+              {
+                $x: runner.tags["x"],
+                $y: runner.tags["y"],
+                $width: runner.tags["width"],
+                $height: runner.tags["height"],
+                $rx: RADIUS,
+                $ry: RADIUS,
+                $fill: "lightgreen",
+                $stroke: "green",
+                "$stroke-width": 5,
+              },
+            ],
+          },
+        ],
+      });
+    }
+  }
+
+  drawTasks(tasks: cleverQueue.tasks.Task[]): void {
+    for (let t = 0; t < tasks.length; t++) {
+      const task = tasks[t];
+      svgFile.svg.g?.push({
+        $id: task.options.id ?? "",
+        g: [
+          {
+            rect: [
+              {
+                $width: TASK_WIDTH,
+                $height: TASK_HEIGHT,
+                $rx: 20,
+                $ry: 20,
+                $fill: "blue",
+              },
+              {
+                $width: 20,
+                $height: 10,
+                $rx: 20,
+                $ry: 20,
+                $fill: "green",
+              },
+            ],
+            text: [{ $dx: TASK_WIDTH / 2, $dy: TASK_HEIGHT / 2, "$dominant-baseline": "middle", "$text-anchor": "middle", $fill: "white", $$content: task.options.id ?? "" }],
+          },
+        ],
+        animateMotion: [
+          {
+            $begin: 0,
+            $dur: 0,
+            $path: "M" + (WIDTH / 2 - TASK_WIDTH / 2) + ",-" + TASK_HEIGHT,
+          },
+        ],
+      });
+    }
+  }
+
+  getLastPoint(animateMotion: svg.AnimateMotion): svg.Point | null {
+    if (!animateMotion) return null;
+    const path = svg.parsePath(animateMotion.$path);
+    console.log(path, path.length);
+    const lastPointInPath = path[path.length - 1];
+    if (!lastPointInPath) return null;
+    console.log(typeof lastPointInPath, "x" in lastPointInPath, lastPointInPath);
+    if ("x" in lastPointInPath && "y" in lastPointInPath) return { x: lastPointInPath.x, y: lastPointInPath.y };
+    return null;
+  }
+
+  getTaskPosition(task: cleverQueue.tasks.Task): { x: number; y: number } {
+    console.log(JSON.stringify({ statistics: task.statistics() }));
+    let x = 0;
+    let y = 0;
+    if (task.status === "queued" && task.queueId) {
+      // task is in a queue
+      for (let q = 0; q < this.engine.queues.length; q++) {
+        const queue = this.engine.queues[q];
+        if (queue.options.id === task.queueId) {
+          x = (queue.tags["x"] as number) + QUEUE_WIDTH / 2 - TASK_WIDTH / 2;
+          const positionInQueue = queue.tasks.findIndex((t) => t.options.id === task.options.id);
+          const availableHeight = QUEUE_HEIGHT - (TASK_HEIGHT + 2 * TASK_MARGIN);
+          let dy = availableHeight / (queue.tasks.length - 1);
+          if (dy > TASK_HEIGHT + TASK_MARGIN) dy = TASK_HEIGHT + TASK_MARGIN;
+          y = (queue.tags["y"] as number) + QUEUE_HEIGHT - (TASK_HEIGHT + TASK_MARGIN) - dy * positionInQueue;
+        }
+      }
+    }
+
+    if (task.status === "running" && task.runnerId) {
+      // task is running
+      for (let r = 0; r < this.engine.runners.length; r++) {
+        const runner = this.engine.runners[r];
+        if (runner.options.id === task.runnerId) {
+          x = (runner.tags["x"] as number) + RUNNER_WIDTH / 2 - TASK_WIDTH / 2;
+          y = (runner.tags["y"] as number) + RUNNER_HEIGHT / 2 - TASK_HEIGHT / 2;
+        }
+      }
+    }
+    if (task.status === "runned") {
+      // task has runned
+      x = WIDTH / 2 - TASK_WIDTH / 2;
+      y = RUNNEDZONE_Y;
+    }
+    return { x: Math.round(x), y: Math.round(y) };
+  }
+
+  animateMotionTasks(tasks: cleverQueue.tasks.Task[]): void {
+    console.log("animateMotionTasks");
+    for (let t = 0; t < tasks.length; t++) {
+      const task = tasks[t];
+      const svgTask = svgFile.svg.g?.find((element) => {
+        return element.$id === task.options.id;
+      }) as svg.G;
+      if (svgTask) {
+        if (!svgTask.animateMotion) svgTask.animateMotion = [];
+        const animateMotion = svgTask.animateMotion[svgTask.animateMotion.length - 1];
+        const startPoint = this.getLastPoint(animateMotion);
+        if (startPoint) {
+          const endPoint: svg.Point = this.getTaskPosition(task);
+          console.log({ startPoint, endPoint });
+          if (startPoint && endPoint) {
+            svgTask.animateMotion.push({
+              //$begin: "id.begin+" + (animateMotion.$begin + INTERVAL).toString + "s",
+              $begin: "start.end+" + this.tick.toString() + "s",
+              $dur: INTERVAL,
+              //$end: animateMotion.$end + INTERVAL,
+              $path: "M" + startPoint.x + "," + startPoint.y + " L" + endPoint.x + "," + endPoint.y,
+            });
+          }
+        }
+      }
+    }
+  }
+}
+export { Animation };

package/examples/src/helpers/index.ts

@@ -0,0 +1,2 @@
+export * as animations from './animations';
+export { myAsyncTaskToExecute } from './myAsyncTaskToExecute';

package/examples/src/helpers/myAsyncTaskToExecute.ts

@@ -0,0 +1,6 @@
+import * as cleverQueue from "clever-queue";
+
+export const myAsyncTaskToExecute : cleverQueue.tasks.FunctionToExecute = async function (message: string, timeout: number) {
+  await new Promise((resolve) => setTimeout(resolve, timeout));
+  return message;
+};

package/examples/src/helpers/svg.ts

@@ -0,0 +1,155 @@
+export { XMLBuilder } from "fast-xml-parser";
+
+const options = {
+  ignoreAttributes: false,
+  attributeNamePrefix: "$",
+  textNodeName: "$$content",
+};
+
+interface Element {
+  $id?: string;
+}
+
+interface G extends Element {
+  g?: G[];
+  rect?: Rect[];
+  text?: Text[];
+  animateMotion?: AnimateMotion[];
+}
+
+interface Svg extends Element {
+  $xmlns: "http://www.w3.org/2000/svg";
+  $width: number;
+  $height: number;
+  g?: G[];
+  rect?: Rect[];
+}
+
+type Stroke = string;
+
+interface Rect extends Element {
+  $width: number;
+  $height: number;
+  $x?: number;
+  $y?: number;
+  $rx?: number;
+  $ry?: number;
+  $fill?: string;
+  $stroke?: Stroke;
+  "$stroke-width"?: number;
+}
+
+interface Text extends Element {
+  $dx: number;
+  $dy: number;
+  "$dominant-baseline": string;
+  "$text-anchor": string;
+  $fill: string;
+  $$content: string;
+}
+
+interface MoveTo extends Point {
+  command: "M" | "m";
+}
+interface LineTo extends Point {
+  command: "L" | "l" | "H" | "h" | "V" | "v";
+}
+interface CubicBezierCurve extends Point {
+  command: "C" | "c" | "S" | "s";
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+}
+interface QuadraticBezierCurve extends Point {
+  command: "Q" | "q" | "T" | "t";
+}
+interface EllipticalArcCurve extends Point {
+  command: "A" | "a";
+}
+interface ClosePath {
+  command: "Z" | "z";
+}
+
+type PathElement =
+  | MoveTo // : M, m
+  | LineTo // : L, l, H, h, V, v
+  | CubicBezierCurve // : C, c, S, s
+  | QuadraticBezierCurve // : Q, q, T, t
+  | EllipticalArcCurve // : A, a
+  | ClosePath; // : Z, z
+
+type Path = PathElement[];
+
+interface Point {
+  x: number;
+  y: number;
+}
+
+interface AnimateMotion extends Element {
+  $begin: string | number;
+  // $end: number;
+  $dur: number;
+  $repeatCount?: number | "indefinite";
+  $path: string;
+}
+
+interface SvgFile {
+  svg: Svg;
+}
+
+function parseNextPointInPath(path: string, start: number): { x: number; y: number; end: number } {
+  let end = start;
+  while (end < path.length && path[end] !== " ") end++;
+  const coordList = path.substring(start, end).split(",");
+  if (coordList.length != 2) throw "parse error parseNextPointInPath " + path + " " + start;
+  return { x: parseInt(coordList[0]), y: parseInt(coordList[1]), end };
+}
+
+function parsePath(path: string): Path {
+  const result: Path = [];
+  let i = 0;
+  while (i < path.length) {
+    const command = path[i];
+    if (command === "M" || command === "m") {
+      const { x, y, end } = parseNextPointInPath(path, i + 1);
+      i = end;
+      const element: MoveTo = { command, x, y };
+      result.push(element);
+    }
+    if (command === "L" || command === "l" || command === "H" || command === "h" || command === "V" || command === "v") {
+      const { x, y, end } = parseNextPointInPath(path, i + 1);
+      i = end;
+      const element: LineTo = { command, x, y };
+      result.push(element);
+    }
+    if (command === "C" || command === "c" || command === "S" || command === "s") {
+      const { x: x1, y: y1, end: end1 } = parseNextPointInPath(path, i + 1);
+      const { x: x2, y: y2, end: end2 } = parseNextPointInPath(path, end1 + 1);
+      const { x, y, end } = parseNextPointInPath(path, end2 + 1);
+      i = end;
+      const element: CubicBezierCurve = { command, x, y, x1, y1, x2, y2 };
+      result.push(element);
+    }
+    if (command === "Q" || command === "q" || command === "T" || command === "t") {
+      const { x, y, end } = parseNextPointInPath(path, i + 1);
+      i = end;
+      const element: QuadraticBezierCurve = { command, x, y };
+      result.push(element);
+    }
+    if (command === "A" || command === "a") {
+      const { x, y, end } = parseNextPointInPath(path, i + 1);
+      i = end;
+      const element: EllipticalArcCurve = { command, x, y };
+      result.push(element);
+    }
+    if (command === "Z" || command === "z") {
+      const element: ClosePath = { command };
+      result.push(element);
+    }
+    i++;
+  }
+  return result;
+}
+
+export { SvgFile, options, G, AnimateMotion, Point, parsePath };

package/examples/src/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "module": "CommonJS",
+    "esModuleInterop": true,
+    "target": "es2022",
+    "moduleResolution": "node",
+    "outDir": "../dist",
+    "lib": [
+      "es2022",
+    ],
+    "strict": true,
+    "useUnknownInCatchVariables": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "display": "Recommended"
+}