async-queue-runner 0.2.0 → 0.3.0

package/README.md

@@ -0,0 +1 @@
+# node-20-typescript-template

package/{_cjs → cjs}/package.json

@@ -1,3 +1,4 @@
-{
-  "type": "commonjs"
-}
+{
+  "type": "commonjs"
+}
+

package/{_esm → esm}/package.json

@@ -1,3 +1,4 @@
-{
-  "type": "module"
-}
+{
+  "type": "module"
+}
+

package/jest.config.js

@@ -0,0 +1,15 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+export default {
+    transform: {
+        '\\.[jt]sx?$': 'ts-jest'
+    },
+    globals: {
+        'ts-jest': {
+            useESM: true
+        }
+    },
+    moduleNameMapper: {
+        '(.+)\\.js': '$1'
+    },
+    extensionsToTreatAsEsm: ['.ts']
+};

package/nodemon.json

@@ -0,0 +1,11 @@
+{
+  "execMap": {
+    "js": "node --enable-source-maps"
+  },
+  "ignore": [
+    "node_modules"
+  ],
+  "watch": [
+    "built/"
+  ]
+}

package/package.json

@@ -1,16 +1,19 @@
 {
   "name": "async-queue-runner",
-  "version": "0.2.0",
+  "version": "0.3.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/",
+    "copy:package:json": "copyfiles ./package.json ./built/ && copyfiles ./esm/package.json ./built/_esm && copyfiles ./cjs/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",
+    "bump": "npm version minor",
     "watch": "tsc --watch --project ./tsconfig.json",
     "test": "jest"
   },
+  "main": "./_cjs/index.js",
+  "module": "./_esm/index.js",
   "exports": {
     "./*": {
       "types": "./_types/*.d.ts",
@@ -19,7 +22,7 @@
       "default": "./_esm/*.js"
     }
   },
-  "types": "./index.d.ts",
+  "types": "./_types/index.d.ts",
   "keywords": [],
   "author": "Eugeny Dementev",
   "license": "MIT",

package/src/action.test.ts

@@ -0,0 +1,14 @@
+import { describe, test, expect } from '@jest/globals';
+import { Delay } from './utils.js';
+
+describe('Action', () => {
+  test('some', async () => {
+    const a = new Delay({ delay: 10 });
+
+    let run = false;
+
+    await a.execute().then(() => run = true)
+
+    expect(run).toBe(true);
+  })
+});

package/src/action.ts

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

package/{_types/index.d.ts → src/index.ts}

@@ -1,4 +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';
+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/src/queue.ts

@@ -0,0 +1,80 @@
+import { Action } from './action.js';
+import { IAction, QueueAction, QueueContext } from './types.js';
+
+export type QueueOpts = {
+  actions: QueueAction[],
+  name: string
+  end: () => void,
+}
+
+export class AsyncQueue {
+  name: string = 'default queue name';
+  queue: QueueAction[] = [];
+  end: () => void;
+
+  loopAction = false;
+
+  context: QueueContext = {
+    push: this.push,
+    stop: () => { this.loopAction = false; },
+    extend: (obj: object) => Object.assign(this.context, obj),
+  };
+
+  constructor(opts: QueueOpts) {
+    this.queue = opts.actions;
+    this.name = opts.name;
+    this.end = opts.end;
+
+    this.push = this.push.bind(this);
+  }
+
+  async delay(timeout: number) {
+    return new Promise((res) => setTimeout(res, timeout));
+  }
+
+  async run(context: object) {
+    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: IAction) {
+    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: QueueAction[]) {
+    this.queue.unshift(...actions);
+  }
+
+  processQueueItem(item: QueueAction) {
+    if (item instanceof Action) {
+      return item
+    } else return new (item as new (...args: any[]) => IAction);
+  }
+}

package/src/runner.test.ts

@@ -0,0 +1,54 @@
+import { describe, test, expect } from '@jest/globals';
+
+import { QueueRunner } from './runner.js';
+import { util } from './utils.js';
+import { QueueContext } from './types.js';
+import { Action } from './action.js';
+
+function anyAction<C>(execute: (context: C & QueueContext) => Promise<void> | void) {
+  class AnyAction extends Action<C> {
+    async execute(context: C & QueueContext): Promise<void> {
+      return execute(context);
+    }
+  }
+
+  return new AnyAction();
+}
+
+
+const order: string[] = []; // queue should fill that array in particular order
+
+const testQueue = [
+  util.delay(10),
+  anyAction(() => { order.push('second') }),
+];
+const testQueue2 = [
+  anyAction(() => { order.push('first') }),
+  util.delay(15),
+  anyAction(() => { order.push('third') }),
+];
+
+describe('Runner', () => {
+  test('order', async () => {
+    return new Promise((res) => {
+      const runner = new QueueRunner();
+
+      runner.addEndListener((name, size) => {
+        console.log('end event:', name, size);
+
+        if (size === 1) {
+          expect(order.toString()).toEqual(['first', 'second'].toString());
+          return
+        }
+
+        expect(size).toEqual(0);
+        expect(order.toString()).toEqual(['first', 'second', 'third'].toString());
+        res(null);
+      });
+
+      runner.add(testQueue);
+      runner.add(testQueue2);
+    });
+  });
+});
+

package/src/runner.ts

@@ -0,0 +1,37 @@
+import { AsyncQueue } from "./queue.js";
+import { IAction } from "./types.js";
+
+type EndListener = (name: string, size: number) => void;
+
+export class QueueRunner {
+  queues = new Map();
+  listeners: EndListener[] = [];
+
+  add(actions: IAction[], context: object = {}, name: string = 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: EndListener) {
+    this.listeners.push(listener);
+  }
+
+  endEvent(name: string) {
+    for (const listener of this.listeners) {
+      listener(name, this.queues.size);
+    }
+  }
+
+  getName() {
+    return Math.random().toString(36).substring(2, 10);
+  }
+}

package/src/types.ts

@@ -0,0 +1,19 @@
+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/src/utils.ts

@@ -0,0 +1,44 @@
+import { Action } from "./action.js";
+import { Branches, QueueContext, IAction } from "./types.js";
+
+export class Delay extends Action<null> {
+  async execute(): Promise<void> {
+    return new Promise(res => {
+      setTimeout(res, this.delay);
+    })
+  }
+}
+
+export const util = {
+  delay(timeout: number) {
+    return new Delay({ delay: timeout });
+  },
+  if<C>(condition: (context: C) => Promise<boolean>, branches: Branches) {
+    class IfAction extends Action<C> {
+      async execute(context: C & QueueContext): Promise<void> {
+        const result = await condition(context);
+
+        if (result) {
+          context.push(branches.then);
+        } else if (branches.else) {
+          context.push(branches.else);
+        }
+      }
+    }
+
+    return new IfAction();
+  },
+  valid<C>(validator: (context: C) => Promise<boolean>, actions: IAction[]) {
+    class Validator extends Action<C> {
+      async execute(context: C & QueueContext): Promise<void> {
+        const valid = await validator(context);
+
+        if (valid) {
+          context.push(actions);
+        }
+      }
+    }
+
+    return new Validator();
+  },
+}

package/tsconfig.cjs.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./built/_cjs/",
+    "inlineSourceMap": false,
+    "moduleResolution": "Node10",
+    "module": "CommonJS"
+  },
+  "exclude": ["./src/*.test.ts"]
+}

package/tsconfig.esm.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./built/_esm/",
+    "inlineSourceMap": false
+  },
+  "exclude": ["./src/*.test.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "@tsconfig/node20/tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./built",
+    "noImplicitAny": false,
+    "inlineSourceMap": true
+  },
+  "include": ["./src/*.ts"]
+}

package/tsconfig.types.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./built/_types/",
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "inlineSourceMap": false
+  },
+  "exclude": ["./src/*.test.ts"]
+}
+

package/_cjs/action.js

@@ -1,11 +0,0 @@
-"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

@@ -1,9 +0,0 @@
-"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/queue.js

@@ -1,62 +0,0 @@
-"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

@@ -1,31 +0,0 @@
-"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

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

package/_cjs/utils.js

@@ -1,42 +0,0 @@
-"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

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

package/_esm/index.js

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

package/_esm/queue.js

@@ -1,58 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

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

package/_esm/utils.js

@@ -1,38 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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/queue.d.ts

@@ -1,19 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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;
-    };
-};