@d-zero/dealer 1.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 D-ZERO Co., Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+# Dealer
+
+Dealer is an API and CLI that processes a given collection in parallel and logs the output in sequence to the standard output.
+
+## Install
+
+```shell
+npm install @d-zero/dealer
+```
+
+## API
+
+```ts
+import { deal } from '@d-zero/dealer';
+
+await deal(items, {
+	limit: 30,
+	header: (progress, done, total, limit) =>
+		progress === 1
+			? 'HeaderMessage: Done!'
+			: `HeaderMessage: %earth% %dots% %block% %propeller%`,
+	setup: (item, update, index) => {
+		item.setup();
+		item.addListeners((state) => {
+			update(`item(${index}): ${state}`);
+		});
+
+		return async () => {
+			await item.start();
+			item.cleanup();
+		};
+	},
+});
+```

package/dist/animate.d.ts

@@ -0,0 +1 @@
+export declare function animate(chars: string[], time: number): string | undefined;

package/dist/animate.js

@@ -0,0 +1,3 @@
+export function animate(chars, time) {
+    return chars[time % chars.length];
+}

package/dist/count-down-function-parser.d.ts

@@ -0,0 +1,6 @@
+export declare function countDownFunctionParser(text: string): {
+    id: string;
+    time: number;
+    placeholder: string;
+    unit: string;
+} | null;

package/dist/count-down-function-parser.js

@@ -0,0 +1,22 @@
+export function countDownFunctionParser(text) {
+    const matched = /%countdown\((?<time>\d+)\s*,\s*(?<id>[^\s),]+)(?:\s*,\s*(?<unit>m?s))?\)%/i.exec(text);
+    if (!matched) {
+        return null;
+    }
+    if (!matched[0] || !matched.groups?.time || !matched.groups?.id) {
+        return null;
+    }
+    const time = Number.parseInt(matched.groups?.time, 10);
+    if (Number.isNaN(time)) {
+        return null;
+    }
+    const unit = matched.groups?.unit === 's' ? 's' : 'ms';
+    const id = matched.groups?.id;
+    const placeholder = matched[0];
+    return {
+        id,
+        time,
+        placeholder,
+        unit,
+    };
+}

package/dist/deal.d.ts

@@ -0,0 +1,8 @@
+import type { DealerOptions } from './dealer.js';
+import type { LanesOptions } from './lanes.js';
+type Options = DealerOptions & LanesOptions & {
+    header?: (progress: number, done: number, total: number, limit: number) => string;
+    debug?: boolean;
+};
+export declare function deal<T extends WeakKey>(items: readonly T[], setup: (process: T, update: (log: string) => void, index: number) => () => void | Promise<void>, options: Options): Promise<void>;
+export {};

package/dist/deal.js

@@ -0,0 +1,32 @@
+import { Dealer } from './dealer.js';
+import { Lanes } from './lanes.js';
+const DEBUG_ID = Number.MIN_SAFE_INTEGER;
+export async function deal(items, setup, options) {
+    const dealer = new Dealer(items, options);
+    const lanes = new Lanes(options);
+    if (options?.header) {
+        dealer.progress((progress, done, total, limit) => {
+            lanes.header(options.header(progress, done, total, limit));
+        });
+    }
+    dealer.setup((process, index) => {
+        const update = (log) => lanes.update(index, log);
+        const start = setup(process, update, index);
+        return async () => {
+            await start();
+            lanes.delete(index);
+        };
+    });
+    if (options.debug) {
+        dealer.debug((log) => {
+            lanes.update(DEBUG_ID, `[DEBUG]: ${log}`);
+        });
+    }
+    return new Promise((resolve) => {
+        dealer.finish(() => {
+            lanes.close();
+            resolve();
+        });
+        dealer.play();
+    });
+}

package/dist/dealer.d.ts

@@ -0,0 +1,13 @@
+import type { ProcessInitializer } from './types.js';
+export interface DealerOptions {
+    limit?: number;
+}
+export declare class Dealer<T extends WeakKey> {
+    #private;
+    constructor(items: readonly T[], options?: DealerOptions);
+    debug(listener: (log: string) => void): void;
+    finish(listener: () => void): void;
+    play(): void;
+    progress(listener: (progress: number, done: number, total: number, limit: number) => void): void;
+    setup(initializer: ProcessInitializer<T>): void;
+}

package/dist/dealer.js

@@ -0,0 +1,70 @@
+export class Dealer {
+    #done = new WeakSet();
+    #doneCount = 0;
+    #items;
+    #limit;
+    #starts = new WeakMap();
+    #workers = new Set();
+    #debug = () => { };
+    #finish = () => { };
+    #progress = () => { };
+    constructor(items, options) {
+        this.#items = items;
+        this.#limit = options?.limit ?? 10;
+    }
+    debug(listener) {
+        this.#debug = listener;
+    }
+    finish(listener) {
+        this.#finish = listener;
+    }
+    play() {
+        this.#deal();
+    }
+    progress(listener) {
+        this.#progress = listener;
+    }
+    setup(initializer) {
+        for (const [index, item] of this.#items.entries()) {
+            const start = initializer(item, index);
+            this.#starts.set(item, async () => await start());
+        }
+        this.#progress(this.#doneCount / this.#items.length, this.#doneCount, this.#items.length, this.#limit);
+    }
+    #deal() {
+        this.#debug(`Done: ${this.#doneCount}/${this.#items.length} (Limit: ${this.#limit})`);
+        this.#progress(this.#doneCount / this.#items.length, this.#doneCount, this.#items.length, this.#limit);
+        if (this.#doneCount === this.#items.length) {
+            this.#finish();
+        }
+        while (this.#workers.size <= this.#limit) {
+            const worker = this.#draw();
+            if (!worker) {
+                return;
+            }
+            this.#workers.add(worker);
+            const start = this.#starts.get(worker);
+            if (!start) {
+                throw new Error(`Didn't have a starting function`);
+            }
+            void start().then(() => {
+                this.#workers.delete(worker);
+                this.#done.add(worker);
+                this.#doneCount++;
+                this.#deal();
+            });
+        }
+    }
+    #draw() {
+        for (const item of this.#items) {
+            if (this.#done.has(item)) {
+                continue;
+            }
+            if (this.#workers.has(item)) {
+                continue;
+            }
+            return item;
+        }
+        return null;
+    }
+}

package/dist/display.d.ts

@@ -0,0 +1,13 @@
+import type { Animations, FPS } from './types.js';
+interface Options {
+    animations?: Animations;
+    fps?: FPS;
+}
+export declare class Display {
+    #private;
+    constructor(options?: Options);
+    close(): void;
+    verboseMode(): void;
+    write(...logs: string[]): void;
+}
+export {};

package/dist/display.js

@@ -0,0 +1,109 @@
+import readline from 'node:readline';
+import c from 'ansi-colors';
+import { countDownFunctionParser } from './count-down-function-parser.js';
+import { riffle } from './riffle.js';
+const RESET = c.reset('');
+const animationPresets = {
+    earth: [2, '🌏', '🌍', '🌎'],
+    dots: [5, '.  ', '.. ', '...'],
+    block: [20, '▘', '▀', '▜', '▉', '▟', '▃', '▖', ' '],
+    propeller: [25, '\\', '|', '/', '-'],
+};
+export class Display {
+    #animations;
+    #coundDownMap = new Map();
+    #debugMessages = [];
+    #frameInterval;
+    #lastWroteLineNum = 0;
+    #stack = null;
+    #startTime = Date.now();
+    #timer = null;
+    #verbose = false;
+    constructor(options) {
+        this.#animations = {
+            ...animationPresets,
+            ...options?.animations,
+        };
+        const fps = options?.fps ?? 30;
+        this.#frameInterval = 1000 / fps;
+        process.stdout.on('resize', () => this.#resize());
+    }
+    close() {
+        if (this.#verbose) {
+            return;
+        }
+        if (this.#timer) {
+            clearTimeout(this.#timer);
+            this.#timer = null;
+        }
+        this.#write();
+        this.#lastWroteLineNum = 0;
+        this.#stack = null;
+    }
+    verboseMode() {
+        this.#verbose = true;
+    }
+    write(...logs) {
+        if (this.#verbose) {
+            process.stdout.write(logs.map((log) => log.trim()).join('\n'));
+            return;
+        }
+        this.#stack = [...this.#debugMessages, ...logs];
+        if (this.#timer) {
+            return;
+        }
+        this.#enterFrame();
+    }
+    #clear() {
+        if (this.#verbose) {
+            return;
+        }
+        for (let i = 0; i < this.#lastWroteLineNum; i++) {
+            readline.moveCursor(process.stdout, 0, -1);
+            readline.cursorTo(process.stdout, 0);
+            readline.clearLine(process.stdout, 0);
+        }
+    }
+    #countDown(text) {
+        const parsed = countDownFunctionParser(text);
+        if (!parsed) {
+            return text;
+        }
+        const { id, time, placeholder, unit } = parsed;
+        const currentTime = this.#coundDownMap.get(id);
+        let displayTimeMS;
+        if (currentTime == null) {
+            this.#coundDownMap.set(id, Date.now());
+            displayTimeMS = time;
+        }
+        else {
+            const elapsedTime = Date.now() - currentTime;
+            displayTimeMS = Math.max(time - elapsedTime, 0);
+        }
+        const displayTime = unit === 's' ? Math.round(displayTimeMS / 1000) : displayTimeMS;
+        return text.replace(placeholder, `${displayTime}`);
+    }
+    #enterFrame() {
+        this.#timer = setTimeout(() => this.#enterFrame(), this.#frameInterval);
+        this.#write();
+    }
+    #resize() {
+        if (this.#verbose) {
+            return;
+        }
+        this.#write();
+    }
+    #write() {
+        if (!this.#stack) {
+            return;
+        }
+        this.#clear();
+        for (const stack of this.#stack) {
+            let text = riffle(stack, Date.now() - this.#startTime, this.#animations);
+            text = this.#countDown(text);
+            const displayText = text.slice(0, process.stdout.columns);
+            process.stdout.write(`${RESET}${displayText}${RESET}\n`);
+        }
+        this.#lastWroteLineNum = this.#stack.length;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { deal } from './deal.js';
+export { Dealer } from './dealer.js';
+export { Lanes } from './lanes.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { deal } from './deal.js';
+export { Dealer } from './dealer.js';
+export { Lanes } from './lanes.js';

package/dist/lanes.d.ts

@@ -0,0 +1,19 @@
+import type { Animations, FPS } from './types.js';
+type Log = [id: number, message: string];
+type SortFunc = (a: Log, b: Log) => number;
+export type LanesOptions = {
+    animations?: Animations;
+    fps?: FPS;
+    indent?: string;
+    sort?: SortFunc;
+};
+export declare class Lanes {
+    #private;
+    constructor(options?: LanesOptions);
+    close(): void;
+    delete(id: number): void;
+    header(text: string): void;
+    update(id: number, log: string): void;
+    write(): void;
+}
+export {};

package/dist/lanes.js

@@ -0,0 +1,40 @@
+import { Display } from './display.js';
+export class Lanes {
+    #display;
+    #header;
+    #indent = '';
+    #logs = new Map();
+    #sort = ([a], [b]) => a - b;
+    constructor(options) {
+        this.#display = new Display({
+            animations: options?.animations,
+            fps: options?.fps,
+        });
+        this.#indent = options?.indent ?? this.#indent;
+        this.#sort = options?.sort ?? this.#sort;
+    }
+    close() {
+        this.#display.close();
+    }
+    delete(id) {
+        this.#logs.delete(id);
+        this.write();
+    }
+    header(text) {
+        this.#header = text;
+        this.write();
+    }
+    update(id, log) {
+        this.#logs.set(id, log);
+        this.write();
+    }
+    write() {
+        const logs = [...this.#logs.entries()];
+        logs.sort(this.#sort);
+        const messages = logs.map(([, message]) => `${this.#indent}${message}`);
+        if (this.#header) {
+            messages.unshift(this.#header);
+        }
+        this.#display.write(...messages);
+    }
+}

package/dist/logger.d.ts

@@ -0,0 +1,14 @@
+import type { Animations, FPS } from './types.js';
+interface Options {
+    animations?: Animations;
+    fps?: FPS;
+}
+export declare class Logger {
+    #private;
+    constructor(options?: Options);
+    clear(): void;
+    close(): void;
+    verboseMode(): void;
+    write(...logs: string[]): void;
+}
+export {};

package/dist/logger.js

@@ -0,0 +1,111 @@
+import readline from 'node:readline';
+import c from 'ansi-colors';
+import { countDownFunctionParser } from './count-down-function-parser.js';
+import { riffle } from './riffle.js';
+import { writeVerbosely } from './write-verbosely.js';
+const animationPresets = {
+    earth: ['🌏', '🌍', '🌎'],
+    dots: ['.  ', '.. ', '...'],
+    block: ['▘', '▀', '▜', '▉', '▟', '▃', '▖', ' '],
+    propeller: ['\\', '|', '/', '-'],
+};
+export class Logger {
+    #animations;
+    #coundDownMap = new Map();
+    #frameInterval;
+    #lastWroteLineNum = 0;
+    #stack = null;
+    #time = 0;
+    #timer = null;
+    #verbose = false;
+    constructor(options) {
+        this.#animations = {
+            ...animationPresets,
+            ...options?.animations,
+        };
+        const fps = options?.fps ?? 30;
+        this.#frameInterval = 1000 / fps;
+        process.stdout.on('resize', () => this.#resize());
+    }
+    clear() {
+        if (this.#verbose) {
+            return;
+        }
+        const cursorY = this.#lastWroteLineNum * -1;
+        readline.moveCursor(process.stdout, 0, cursorY);
+        readline.cursorTo(process.stdout, 0);
+    }
+    close() {
+        if (this.#verbose) {
+            return;
+        }
+        // Writing last stack
+        if (this.#timer) {
+            clearTimeout(this.#timer);
+            this.#timer = null;
+        }
+        this.#write();
+        this.#time = 0;
+        this.#lastWroteLineNum = 0;
+        this.#stack = null;
+    }
+    verboseMode() {
+        this.#verbose = true;
+    }
+    write(...logs) {
+        if (this.#verbose) {
+            writeVerbosely(...logs);
+            return;
+        }
+        this.#stack = logs;
+        if (this.#timer) {
+            return;
+        }
+        this.#run();
+    }
+    #countDown(text) {
+        const parsed = countDownFunctionParser(text);
+        if (!parsed) {
+            return text;
+        }
+        const { id, time, placeholder, unit } = parsed;
+        const currentTime = this.#coundDownMap.get(id);
+        let displayTimeMS;
+        if (currentTime == null) {
+            this.#coundDownMap.set(id, Date.now());
+            displayTimeMS = time;
+        }
+        else {
+            const elapsedTime = Date.now() - currentTime;
+            displayTimeMS = Math.max(time - elapsedTime, 0);
+        }
+        const displayTime = unit === 's' ? Math.round(displayTimeMS / 1000) : displayTimeMS;
+        return text.replace(placeholder, `${displayTime}`);
+    }
+    #resize() {
+        if (this.#verbose) {
+            return;
+        }
+        this.#write();
+    }
+    #run() {
+        this.#time += 1;
+        this.#timer = setTimeout(() => this.#run(), this.#frameInterval);
+        this.#write();
+    }
+    #write() {
+        if (!this.#stack) {
+            return;
+        }
+        this.clear();
+        const reset = c.reset('');
+        for (const line of this.#stack) {
+            readline.clearLine(process.stdout, 0);
+            let text = riffle(line, this.#time, this.#animations ?? {});
+            text = this.#countDown(text);
+            const displayText = text.slice(0, process.stdout.columns);
+            process.stdout.write(`${reset}${displayText}${reset}\n`);
+        }
+        this.#lastWroteLineNum = this.#stack.length;
+    }
+}

package/dist/riffle.d.ts

@@ -0,0 +1,2 @@
+import type { Animations } from './types.js';
+export declare function riffle(text: string, elapsed: number, animations: Animations): string;

package/dist/riffle.js

@@ -0,0 +1,17 @@
+export function riffle(text, elapsed, animations) {
+    for (const key of Object.keys(animations)) {
+        const animation = animations[key];
+        if (!animation) {
+            continue;
+        }
+        const [fps, ...sprites] = animation;
+        const frameDuration = 1000 / fps;
+        const currentFrame = Math.floor(elapsed / frameDuration) % sprites.length;
+        const replacement = sprites[currentFrame];
+        if (!replacement) {
+            continue;
+        }
+        text = text.replaceAll(`%${key}%`, replacement);
+    }
+    return text;
+}

package/dist/types.d.ts

@@ -0,0 +1,5 @@
+export type Animations = Record<string, [fps: number, ...sprites: string[]]>;
+export type FPS = 12 | 24 | 30 | 60;
+export interface ProcessInitializer<T> {
+    (process: T, index: number): () => Promise<void> | void;
+}

package/dist/types.js

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

package/dist/write-verbosely.d.ts

@@ -0,0 +1 @@
+export declare function writeVerbosely(...lines: string[]): void;

package/dist/write-verbosely.js

@@ -0,0 +1,3 @@
+export function writeVerbosely(...lines) {
+    process.stdout.write(lines.map((line) => line.trim()).join('\n'));
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+	"name": "@d-zero/dealer",
+	"version": "1.0.0-alpha.1",
+	"description": "A tool that provides an API and CLI for parallel processing of collections and sequential logging to standard output",
+	"author": "D-ZERO",
+	"license": "MIT",
+	"private": false,
+	"publishConfig": {
+		"access": "public"
+	},
+	"type": "module",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "tsc",
+		"clean": "tsc --build --clean"
+	},
+	"dependencies": {
+		"ansi-colors": "4.1.3"
+	},
+	"gitHead": "feffce2ac8ca616a0fbca4b19987c3bff5291d3d"
+}