in-parallel-lit 1.0.0 → 3.0.0

package/README.md

@@ -6,8 +6,6 @@ A CLI tool to run multiple processes in parallel.
 
 ```bash
 $ npm i -g in-parallel-lit
-# or
-$ yarn global add in-parallel-lit
 ```
 
 ## Usage
@@ -151,9 +149,3 @@ $ ./Taskfile.sh validate
 
 (3) Start developing. See [`./Taskfile.sh`](./Taskfile.sh) for more tasks to
     help you develop.
-
----
-
-_This project was set up by @jvdx/core_
-
-[install-node]: https://github.com/nvm-sh/nvm

package/dist/bin.cjs

@@ -0,0 +1,438 @@
+#!/usr/bin/env node
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_module = require("node:module");
+let sade = require("sade");
+sade = __toESM(sade);
+let node_stream = require("node:stream");
+let node_string_decoder = require("node:string_decoder");
+let cross_spawn = require("cross-spawn");
+let node_os = require("node:os");
+node_os = __toESM(node_os);
+//#region src/lib/get-signal-num.ts
+var signals = {
+	SIGABRT: 6,
+	SIGALRM: 14,
+	SIGBUS: 10,
+	SIGCHLD: 20,
+	SIGCONT: 19,
+	SIGFPE: 8,
+	SIGHUP: 1,
+	SIGILL: 4,
+	SIGINT: 2,
+	SIGKILL: 9,
+	SIGPIPE: 13,
+	SIGQUIT: 3,
+	SIGSEGV: 11,
+	SIGSTOP: 17,
+	SIGTERM: 15,
+	SIGTRAP: 5,
+	SIGTSTP: 18,
+	SIGTTIN: 21,
+	SIGTTOU: 22,
+	SIGUSR1: 30,
+	SIGUSR2: 31
+};
+/**
+* Converts a signal name to a number.
+*/
+function getSignalNumber(signal) {
+	return signals[signal] || 0;
+}
+//#endregion
+//#region src/lib/get-stream-kind.ts
+/**
+* Converts a given stream to an option for `child_process.spawn`.
+*/
+function getStreamKind(stream, std) {
+	if (stream == null) return "ignore";
+	if (stream !== std || !std.isTTY) return "pipe";
+	return stream;
+}
+//#endregion
+//#region src/lib/in-parallel-error.ts
+var InParallelError = class extends Error {
+	code;
+	results;
+	constructor(causeResult, allResults) {
+		super(`"${causeResult.name}" exited with ${causeResult.code}.`);
+		this.name = causeResult.name;
+		this.code = causeResult.code;
+		this.results = allResults;
+	}
+};
+//#endregion
+//#region src/lib/memory-writable.ts
+var noop = () => {};
+var MemoryWritable = class extends node_stream.Writable {
+	queue = [];
+	data;
+	constructor(data = null) {
+		super();
+		this.data = Array.isArray(data) ? data : [data];
+		this.queue = [];
+		for (let chunk of this.data) {
+			if (chunk == null) continue;
+			if (!(chunk instanceof Buffer)) chunk = Buffer.from(chunk);
+			this.queue.push(chunk);
+		}
+	}
+	_write(chunk, enc, cb = noop) {
+		let decoder = null;
+		try {
+			decoder = enc && enc !== "buffer" ? new node_string_decoder.StringDecoder(enc) : null;
+		} catch (err) {
+			return cb(err);
+		}
+		let decodedChunk = decoder != null ? decoder.write(chunk) : chunk;
+		this.queue.push(Buffer.isBuffer(decodedChunk) ? decodedChunk : Buffer.from(decodedChunk));
+		cb();
+	}
+	_getQueueSize() {
+		let size = 0;
+		for (let i = 0; i < this.queue.length; i++) size += this.queue[i].length;
+		return size;
+	}
+	toString() {
+		let str = "";
+		for (const chunk of this.queue) str += chunk.toString();
+		return str;
+	}
+	toBuffer() {
+		const buffer = Buffer.alloc(this._getQueueSize());
+		let currentOffset = 0;
+		for (const chunk of this.queue) {
+			chunk.copy(buffer, currentOffset);
+			currentOffset += chunk.length;
+		}
+		return buffer;
+	}
+};
+//#endregion
+//#region src/lib/remove-from-arr.ts
+/**
+* removeFromArr removes an `item` from `arr`.
+*/
+function removeFromArr(arr, item) {
+	const index = arr.indexOf(item);
+	if (index !== -1) arr.splice(index, 1);
+}
+//#endregion
+//#region src/lib/kill-pids.ts
+/**
+* Wrap crossSpawn in a Promise
+*/
+function crossSpawnPromise(cmd, args = [], options = {}) {
+	return new Promise((resolve, reject) => {
+		let stdout = "";
+		let stderr = "";
+		const ch = (0, cross_spawn.spawn)(cmd, args, options);
+		if (ch.stdout === null || ch.stderr === null) return reject("stdout/stderr is null");
+		ch.stdout.on("data", (d) => {
+			stdout += d.toString();
+		});
+		ch.stderr.on("data", (d) => {
+			stderr += d.toString();
+		});
+		ch.on("error", (err) => reject(err));
+		ch.on("close", (code) => {
+			if (stderr) return reject(stderr);
+			if (code !== 0) return reject(`${cmd} exited with code ${code}`);
+			return resolve(stdout);
+		});
+	});
+}
+/**
+* Kills a process by ID and all its subprocesses.
+*/
+async function killPids(pid, platform = process.platform) {
+	if (platform === "win32") {
+		(0, cross_spawn.spawn)("taskkill", [
+			"/F",
+			"/T",
+			"/PID",
+			String(pid)
+		]);
+		return;
+	}
+	try {
+		const stdoutRows = (await crossSpawnPromise("ps", [
+			"-A",
+			"-o",
+			"ppid,pid"
+		])).split(node_os.default.EOL);
+		let pidExists = false;
+		const pidTree = {};
+		for (let i = 1; i < stdoutRows.length; i++) {
+			stdoutRows[i] = stdoutRows[i].trim();
+			if (!stdoutRows[i]) continue;
+			const stdoutTuple = stdoutRows[i].split(/\s+/);
+			const stdoutPpid = parseInt(stdoutTuple[0], 10);
+			const stdoutPid = parseInt(stdoutTuple[1], 10);
+			if (!pidExists && stdoutPid === pid || !pidExists && stdoutPpid === pid) pidExists = true;
+			if (pidTree[stdoutPpid]) pidTree[stdoutPpid].push(stdoutPid);
+			else pidTree[stdoutPpid] = [stdoutPid];
+		}
+		if (!pidExists) return;
+		let idx = 0;
+		const pids = [pid];
+		while (idx < pids.length) {
+			const curpid = pids[idx++];
+			if (!pidTree[curpid]) continue;
+			for (let j = 0; j < pidTree[curpid].length; j++) pids.push(pidTree[curpid][j]);
+			delete pidTree[curpid];
+		}
+		for (const pid of pids) process.kill(pid);
+	} catch {}
+}
+//#endregion
+//#region src/lib/spawn.ts
+/**
+* Launches a new process with the given command.
+* This is almost same as `child_process.spawn`, but it adds a `kill` method
+* that kills the instance process and its sub processes.
+*/
+function spawn(command, args, options) {
+	const child = (0, cross_spawn.spawn)(command, args, options);
+	child.kill = function kill() {
+		killPids(this.pid);
+		return true;
+	};
+	return child;
+}
+//#endregion
+//#region src/lib/prefix-transform.ts
+var ALL_BR = /\n/g;
+var PrefixTransform = class extends node_stream.Transform {
+	prefix;
+	lastPrefix;
+	lastIsLinebreak;
+	constructor(prefix) {
+		super();
+		this.prefix = prefix;
+		this.lastPrefix = null;
+		this.lastIsLinebreak = true;
+	}
+	_transform(chunk, _enc, cb) {
+		const prefixed = `${this.lastIsLinebreak ? this.prefix : this.lastPrefix !== this.prefix ? "\n" : ""}${chunk}`.replace(ALL_BR, `\n${this.prefix}`);
+		const index = prefixed.indexOf(this.prefix, Math.max(0, prefixed.length - this.prefix.length));
+		this.lastPrefix = this.prefix;
+		this.lastIsLinebreak = index !== -1;
+		cb(null, index !== -1 ? prefixed.slice(0, index) : prefixed);
+	}
+};
+//#endregion
+//#region src/lib/select-color.ts
+var FORCE_COLOR;
+var NODE_DISABLE_COLORS;
+var NO_COLOR;
+var TERM;
+var isTTY = true;
+var enabled;
+/**
+* Check if color support is enabled.
+*/
+function checkColorSupport() {
+	if (enabled != null) return;
+	({FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM} = process.env);
+	isTTY = process.stdout?.isTTY;
+	enabled = !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY);
+}
+/**
+* Returns functions that wrap a given string with color char codes.
+*/
+function createColor(x, y) {
+	const rgx = new RegExp(`\\x1b\\[${y}m`, "g");
+	const open = `\x1b[${x}m`;
+	const close = `\x1b[${y}m`;
+	return function(txt) {
+		checkColorSupport();
+		if (!enabled) return txt;
+		return open + (~`${txt}`.indexOf(close) ? txt.replace(rgx, close + open) : txt) + close;
+	};
+}
+var colors = [
+	createColor(36, 39),
+	createColor(32, 39),
+	createColor(35, 39),
+	createColor(33, 39),
+	createColor(31, 39)
+];
+var colorIndex = 0;
+var taskNamesToColors = /* @__PURE__ */ new Map();
+/**
+* Select a color from given task name.
+*/
+function selectColor(taskName) {
+	let color = taskNamesToColors.get(taskName);
+	if (color == null) {
+		color = colors[colorIndex];
+		colorIndex = (colorIndex + 1) % colors.length;
+		taskNamesToColors.set(taskName, color);
+	}
+	return color;
+}
+//#endregion
+//#region src/lib/wrap-stream-with-label.ts
+/**
+* Wraps stdout/stderr with a transform stream to add the task name as prefix.
+*/
+function wrapStreamWithLabel(source, label) {
+	if (source == null) return source;
+	const target = new PrefixTransform((source.isTTY ? selectColor(label) : (x) => x)(`[${label}] `));
+	target.pipe(source);
+	return target;
+}
+//#endregion
+//#region src/index.ts
+/**
+* prog represents the main program logic.
+*/
+function prog(opts, proc) {
+	const { _: tasks, ...options } = opts;
+	const customTaskNames = options.names != null ? options.names.split(",").map((n) => n.trim()) : [];
+	return new Promise((resolve, reject) => {
+		let results = [];
+		let queue = [];
+		let promises = [];
+		let error = null;
+		let aborted = false;
+		if (tasks.length === 0) return done();
+		for (let i = 0; i < tasks.length; i++) {
+			results.push({
+				name: tasks[i],
+				code: void 0
+			});
+			queue.push({
+				name: tasks[i],
+				index: i
+			});
+		}
+		function done() {
+			if (error == null) return resolve(results);
+			return reject(error);
+		}
+		function abort() {
+			if (aborted) return;
+			aborted = true;
+			if (promises.length === 0) return done();
+			for (const p of promises) p.abort();
+			return Promise.all(promises).then(done, reject);
+		}
+		function next() {
+			if (aborted) return;
+			if (queue.length === 0) {
+				if (promises.length === 0) return done();
+				return;
+			}
+			const task = queue.shift();
+			if (task == null) return;
+			const originalOutputStream = proc.stdout;
+			const optionsClone = {
+				stdout: proc.stdout,
+				stderr: proc.stderr,
+				stdin: proc.stdin,
+				customName: customTaskNames[task.index]
+			};
+			const writer = new MemoryWritable();
+			if (options["aggregate-output"]) optionsClone.stdout = writer;
+			const promise = runTask(task.name, optionsClone);
+			promises.push(promise);
+			promise.then((result) => {
+				removeFromArr(promises, promise);
+				if (aborted) return;
+				if (options["aggregate-output"]) originalOutputStream.write(writer.toString());
+				if (result.code === null && result.signal !== null) result.code = 128 + getSignalNumber(result.signal);
+				results[task.index].code = result.code;
+				if (result.code) {
+					error = new InParallelError(result, results);
+					if (!options["continue-on-error"]) return abort();
+				}
+				next();
+			}, (err) => {
+				removeFromArr(promises, promise);
+				if (!options["continue-on-error"]) {
+					error = err;
+					return abort();
+				}
+				next();
+			});
+		}
+		let end = tasks.length;
+		if (typeof options["max-parallel"] === "number" && options["max-parallel"] > 0) end = Math.min(tasks.length, options["max-parallel"]);
+		for (let i = 0; i < end; ++i) next();
+	});
+}
+/**
+* runTask executes a single task as a child process.
+*/
+function runTask(name, opts) {
+	let proc = null;
+	const task = new Promise((resolve, reject) => {
+		const stdin = opts.stdin;
+		const stdout = wrapStreamWithLabel(opts.stdout, opts.customName || name);
+		const stderr = wrapStreamWithLabel(opts.stderr, opts.customName || name);
+		const stdinKind = getStreamKind(stdin, process.stdin);
+		const stdoutKind = getStreamKind(stdout, process.stdout);
+		const stderrKind = getStreamKind(stderr, process.stderr);
+		const [spawnName, ...spawnArgs] = name.split(" ");
+		proc = spawn(spawnName, spawnArgs, { stdio: [
+			stdinKind,
+			stdoutKind,
+			stderrKind
+		] });
+		if (proc == null) return reject("Failed to spawn process");
+		if (stdinKind === "pipe") stdin.pipe(proc.stdin);
+		if (stdoutKind === "pipe") proc.stdout.pipe(stdout, { end: false });
+		if (stderrKind === "pipe") proc.stderr.pipe(stderr, { end: false });
+		proc.on("error", (err) => {
+			proc = null;
+			return reject(err);
+		});
+		proc.on("close", (code, signal) => {
+			proc = null;
+			return resolve({
+				name,
+				code,
+				signal
+			});
+		});
+	});
+	task.abort = () => {
+		if (proc == null) return;
+		proc.kill();
+		proc = null;
+	};
+	return task;
+}
+//#endregion
+//#region src/bin.ts
+async function run(argv) {
+	const packageJson = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("../package.json");
+	process.stdout.setMaxListeners(0);
+	process.stderr.setMaxListeners(0);
+	process.stdin.setMaxListeners(0);
+	(0, sade.default)("in-parallel", true).version(packageJson.version).describe(packageJson.description).option(`-n, --names`, `List of custom names to be used in prefix template.`).example(`-n "first,second" "ping google.com" "ping 172.0.0.1"`).option(`-c, --continue-on-error`, `Set the flag to continue executing other/subsequent tasks even if a task threw an error. 'in-parallel' itself will exit with non-zero code if one or more tasks threw error(s).`).option(`--max-parallel`, `Set the maximum number of parallelism. Default is unlimited.`, 0).option(`--aggregate-output`, `Avoid interleaving output by delaying printing of each command's output until it has finished.`, false).action((opts) => prog(opts, process)).parse(argv);
+}
+run(process.argv);
+//#endregion