async-queue-runner 0.1.0

package/_cjs/action.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Action = void 0;
+class Action {
+    delay = 0;
+    constructor(opts = {}) {
+        if (opts.delay)
+            this.delay = opts.delay;
+    }
+}
+exports.Action = Action;

package/_cjs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.util = exports.Action = exports.AsyncQueue = void 0;
+var queue_js_1 = require("./queue.js");
+Object.defineProperty(exports, "AsyncQueue", { enumerable: true, get: function () { return queue_js_1.AsyncQueue; } });
+var action_js_1 = require("./action.js");
+Object.defineProperty(exports, "Action", { enumerable: true, get: function () { return action_js_1.Action; } });
+var utils_js_1 = require("./utils.js");
+Object.defineProperty(exports, "util", { enumerable: true, get: function () { return utils_js_1.util; } });

package/_cjs/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "async-queue-runner",
+  "version": "0.1.0",
+  "description": "Library to run in parallel extendable queue of tasks",
+  "type": "module",
+  "scripts": {
+    "compile": "tsc --project ./tsconfig.json",
+    "copy:package:json": "copyfiles ./package.json ./built/ && copyfiles ./package.json ./built/_esm/ && copyfiles ./package.json ./built/_cjs/",
+    "build:all": "tsc -p ./tsconfig.esm.json && tsc -p ./tsconfig.cjs.json && tsc -p ./tsconfig.types.json",
+    "build": "del-cli ./built/ && npm run build:all && npm run copy:package:json",
+    "watch": "tsc --watch --project ./tsconfig.json",
+    "test": "jest"
+  },
+  "exports": {
+    "./*": {
+      "types": "./_types/*.d.ts",
+      "require": "./_cjs/*.js",
+      "import": "./_esm/*.js",
+      "default": "./_esm/*.js"
+    }
+  },
+  "types": "./index.d.ts",
+  "keywords": [],
+  "author": "Eugeny Dementev",
+  "license": "MIT",
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@tsconfig/node20": "^20.1.2",
+    "@types/node": "^20.11.26",
+    "copyfiles": "^2.4.1",
+    "del-cli": "^5.1.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2"
+  },
+  "dependencies": {
+    "typescript": "^5.4.2"
+  }
+}

package/_cjs/queue.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncQueue = void 0;
+const action_js_1 = require("./action.js");
+class AsyncQueue {
+    name = 'default queue name';
+    queue = [];
+    end;
+    loopAction = false;
+    context = {
+        push: this.push,
+        stop: () => { this.loopAction = false; },
+        extend: (obj) => Object.assign(this.context, obj),
+    };
+    constructor(opts) {
+        this.queue = opts.actions;
+        this.name = opts.name;
+        this.end = opts.end;
+        this.push = this.push.bind(this);
+    }
+    async delay(timeout) {
+        return new Promise((res) => setTimeout(res, timeout));
+    }
+    async run(context) {
+        this.loopAction = true;
+        Object.assign(this.context, context);
+        try {
+            while (this.loopAction) {
+                if (this.queue.length === 0) {
+                    this.loopAction = false;
+                    console.log('Queue stopped');
+                    break;
+                }
+                const item = this.queue.shift();
+                const action = this.processQueueItem(item);
+                await this.iterate(action);
+            }
+            this.end();
+        }
+        catch (e) {
+            console.log(`Queue(${this.name} failed`);
+            console.error(e);
+        }
+    }
+    async iterate(action) {
+        const actionName = action.constructor.name || 'some undefined';
+        console.log(`Queue(${this.name}): running ${actionName} action`);
+        await action.execute(this.context);
+        await this.delay(action.delay);
+    }
+    push(actions) {
+        this.queue.unshift(...actions);
+    }
+    processQueueItem(item) {
+        if (item instanceof action_js_1.Action) {
+            return item;
+        }
+        else
+            return new item;
+    }
+}
+exports.AsyncQueue = AsyncQueue;

package/_cjs/runner.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueRunner = void 0;
+const queue_js_1 = require("./queue.js");
+class QueueRunner {
+    queues = new Map();
+    listeners = [];
+    add(actions, context = {}, name = this.getName()) {
+        const queue = new queue_js_1.AsyncQueue({
+            name, actions,
+            end: () => {
+                this.queues.delete(name);
+                this.endEvent(name);
+            }
+        });
+        this.queues.set(name, queue);
+        queue.run(context);
+    }
+    addEndListener(listener) {
+        this.listeners.push(listener);
+    }
+    endEvent(name) {
+        for (const listener of this.listeners) {
+            listener(name, this.queues.size);
+        }
+    }
+    getName() {
+        return Math.random().toString(36).substring(2, 10);
+    }
+}
+exports.QueueRunner = QueueRunner;

package/_cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/_cjs/utils.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.util = exports.Delay = void 0;
+const action_js_1 = require("./action.js");
+class Delay extends action_js_1.Action {
+    async execute() {
+        return new Promise(res => {
+            setTimeout(res, this.delay);
+        });
+    }
+}
+exports.Delay = Delay;
+exports.util = {
+    delay(timeout) {
+        return new Delay({ delay: timeout });
+    },
+    if(condition, branches) {
+        class IfAction extends action_js_1.Action {
+            async execute(context) {
+                const result = await condition(context);
+                if (result) {
+                    context.push(branches.then);
+                }
+                else if (branches.else) {
+                    context.push(branches.else);
+                }
+            }
+        }
+        return new IfAction();
+    },
+    valid(validator, actions) {
+        class Validator extends action_js_1.Action {
+            async execute(context) {
+                const valid = await validator(context);
+                if (valid) {
+                    context.push(actions);
+                }
+            }
+        }
+        return new Validator();
+    },
+};

package/_esm/action.js

@@ -0,0 +1,7 @@
+export class Action {
+    delay = 0;
+    constructor(opts = {}) {
+        if (opts.delay)
+            this.delay = opts.delay;
+    }
+}

package/_esm/index.js

@@ -0,0 +1,3 @@
+export { AsyncQueue } from './queue.js';
+export { Action } from './action.js';
+export { util } from './utils.js';

package/_esm/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "async-queue-runner",
+  "version": "0.1.0",
+  "description": "Library to run in parallel extendable queue of tasks",
+  "type": "module",
+  "scripts": {
+    "compile": "tsc --project ./tsconfig.json",
+    "copy:package:json": "copyfiles ./package.json ./built/ && copyfiles ./package.json ./built/_esm/ && copyfiles ./package.json ./built/_cjs/",
+    "build:all": "tsc -p ./tsconfig.esm.json && tsc -p ./tsconfig.cjs.json && tsc -p ./tsconfig.types.json",
+    "build": "del-cli ./built/ && npm run build:all && npm run copy:package:json",
+    "watch": "tsc --watch --project ./tsconfig.json",
+    "test": "jest"
+  },
+  "exports": {
+    "./*": {
+      "types": "./_types/*.d.ts",
+      "require": "./_cjs/*.js",
+      "import": "./_esm/*.js",
+      "default": "./_esm/*.js"
+    }
+  },
+  "types": "./index.d.ts",
+  "keywords": [],
+  "author": "Eugeny Dementev",
+  "license": "MIT",
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@tsconfig/node20": "^20.1.2",
+    "@types/node": "^20.11.26",
+    "copyfiles": "^2.4.1",
+    "del-cli": "^5.1.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2"
+  },
+  "dependencies": {
+    "typescript": "^5.4.2"
+  }
+}

package/_esm/queue.js

@@ -0,0 +1,58 @@
+import { Action } from './action.js';
+export class AsyncQueue {
+    name = 'default queue name';
+    queue = [];
+    end;
+    loopAction = false;
+    context = {
+        push: this.push,
+        stop: () => { this.loopAction = false; },
+        extend: (obj) => Object.assign(this.context, obj),
+    };
+    constructor(opts) {
+        this.queue = opts.actions;
+        this.name = opts.name;
+        this.end = opts.end;
+        this.push = this.push.bind(this);
+    }
+    async delay(timeout) {
+        return new Promise((res) => setTimeout(res, timeout));
+    }
+    async run(context) {
+        this.loopAction = true;
+        Object.assign(this.context, context);
+        try {
+            while (this.loopAction) {
+                if (this.queue.length === 0) {
+                    this.loopAction = false;
+                    console.log('Queue stopped');
+                    break;
+                }
+                const item = this.queue.shift();
+                const action = this.processQueueItem(item);
+                await this.iterate(action);
+            }
+            this.end();
+        }
+        catch (e) {
+            console.log(`Queue(${this.name} failed`);
+            console.error(e);
+        }
+    }
+    async iterate(action) {
+        const actionName = action.constructor.name || 'some undefined';
+        console.log(`Queue(${this.name}): running ${actionName} action`);
+        await action.execute(this.context);
+        await this.delay(action.delay);
+    }
+    push(actions) {
+        this.queue.unshift(...actions);
+    }
+    processQueueItem(item) {
+        if (item instanceof Action) {
+            return item;
+        }
+        else
+            return new item;
+    }
+}

package/_esm/runner.js

@@ -0,0 +1,27 @@
+import { AsyncQueue } from "./queue.js";
+export class QueueRunner {
+    queues = new Map();
+    listeners = [];
+    add(actions, context = {}, name = this.getName()) {
+        const queue = new AsyncQueue({
+            name, actions,
+            end: () => {
+                this.queues.delete(name);
+                this.endEvent(name);
+            }
+        });
+        this.queues.set(name, queue);
+        queue.run(context);
+    }
+    addEndListener(listener) {
+        this.listeners.push(listener);
+    }
+    endEvent(name) {
+        for (const listener of this.listeners) {
+            listener(name, this.queues.size);
+        }
+    }
+    getName() {
+        return Math.random().toString(36).substring(2, 10);
+    }
+}

package/_esm/types.js

@@ -0,0 +1 @@
+export {};

package/_esm/utils.js

@@ -0,0 +1,38 @@
+import { Action } from "./action.js";
+export class Delay extends Action {
+    async execute() {
+        return new Promise(res => {
+            setTimeout(res, this.delay);
+        });
+    }
+}
+export const util = {
+    delay(timeout) {
+        return new Delay({ delay: timeout });
+    },
+    if(condition, branches) {
+        class IfAction extends Action {
+            async execute(context) {
+                const result = await condition(context);
+                if (result) {
+                    context.push(branches.then);
+                }
+                else if (branches.else) {
+                    context.push(branches.else);
+                }
+            }
+        }
+        return new IfAction();
+    },
+    valid(validator, actions) {
+        class Validator extends Action {
+            async execute(context) {
+                const valid = await validator(context);
+                if (valid) {
+                    context.push(actions);
+                }
+            }
+        }
+        return new Validator();
+    },
+};

package/_types/action.d.ts

@@ -0,0 +1,9 @@
+import { IAction, QueueContext } from "./types.js";
+export type Options = {
+    delay?: number;
+};
+export declare abstract class Action<C> implements IAction {
+    delay: number;
+    constructor(opts?: Options);
+    abstract execute(context: C & QueueContext): Promise<void>;
+}

package/_types/index.d.ts

@@ -0,0 +1,4 @@
+export { IAction, ActionClass, QueueAction, Branches, QueueContext } from './types.js';
+export { AsyncQueue, QueueOpts } from './queue.js';
+export { Action, Options } from './action.js';
+export { util } from './utils.js';

package/_types/queue.d.ts

@@ -0,0 +1,19 @@
+import { IAction, QueueAction, QueueContext } from './types.js';
+export type QueueOpts = {
+    actions: QueueAction[];
+    name: string;
+    end: () => void;
+};
+export declare class AsyncQueue {
+    name: string;
+    queue: QueueAction[];
+    end: () => void;
+    loopAction: boolean;
+    context: QueueContext;
+    constructor(opts: QueueOpts);
+    delay(timeout: number): Promise<unknown>;
+    run(context: object): Promise<void>;
+    iterate(action: IAction): Promise<void>;
+    push(actions: QueueAction[]): void;
+    processQueueItem(item: QueueAction): IAction;
+}

package/_types/runner.d.ts

@@ -0,0 +1,11 @@
+import { IAction } from "./types.js";
+type EndListener = (name: string, size: number) => void;
+export declare class QueueRunner {
+    queues: Map<any, any>;
+    listeners: EndListener[];
+    add(actions: IAction[], context?: object, name?: string): void;
+    addEndListener(listener: EndListener): void;
+    endEvent(name: string): void;
+    getName(): string;
+}
+export {};

package/_types/types.d.ts

@@ -0,0 +1,15 @@
+export interface IAction {
+    delay: number;
+    execute: (context: any) => Promise<void>;
+}
+export type ActionClass = new (...args: any[]) => IAction;
+export type QueueAction = IAction | ActionClass;
+export type Branches = {
+    then: QueueAction[];
+    else?: QueueAction[];
+};
+export type QueueContext = {
+    push: (actions: QueueAction[]) => void;
+    extend: (obj: Partial<object>) => void;
+    stop: () => void;
+};

package/_types/utils.d.ts

@@ -0,0 +1,16 @@
+import { Action } from "./action.js";
+import { Branches, QueueContext, IAction } from "./types.js";
+export declare class Delay extends Action<null> {
+    execute(): Promise<void>;
+}
+export declare const util: {
+    delay(timeout: number): Delay;
+    if<C>(condition: (context: C) => Promise<boolean>, branches: Branches): {
+        execute(context: C & QueueContext): Promise<void>;
+        delay: number;
+    };
+    valid<C_1>(validator: (context: C_1) => Promise<boolean>, actions: IAction[]): {
+        execute(context: C_1 & QueueContext): Promise<void>;
+        delay: number;
+    };
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "async-queue-runner",
+  "version": "0.1.0",
+  "description": "Library to run in parallel extendable queue of tasks",
+  "type": "module",
+  "scripts": {
+    "compile": "tsc --project ./tsconfig.json",
+    "copy:package:json": "copyfiles ./package.json ./built/ && copyfiles ./package.json ./built/_esm/ && copyfiles ./package.json ./built/_cjs/",
+    "build:all": "tsc -p ./tsconfig.esm.json && tsc -p ./tsconfig.cjs.json && tsc -p ./tsconfig.types.json",
+    "build": "del-cli ./built/ && npm run build:all && npm run copy:package:json",
+    "watch": "tsc --watch --project ./tsconfig.json",
+    "test": "jest"
+  },
+  "exports": {
+    "./*": {
+      "types": "./_types/*.d.ts",
+      "require": "./_cjs/*.js",
+      "import": "./_esm/*.js",
+      "default": "./_esm/*.js"
+    }
+  },
+  "types": "./index.d.ts",
+  "keywords": [],
+  "author": "Eugeny Dementev",
+  "license": "MIT",
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@tsconfig/node20": "^20.1.2",
+    "@types/node": "^20.11.26",
+    "copyfiles": "^2.4.1",
+    "del-cli": "^5.1.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2"
+  },
+  "dependencies": {
+    "typescript": "^5.4.2"
+  }
+}