in-parallel-lit 1.0.0 → 2.0.0

package/dist/bin.js

@@ -0,0 +1,411 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { createRequire } from "node:module";
+import sade from "sade";
+import { Writable, Transform } from "node:stream";
+import { StringDecoder } from "node:string_decoder";
+import { spawn as spawn$1 } from "cross-spawn";
+import os from "node:os";
+const 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
+};
+function getSignalNumber(signal) {
+  return signals[signal] || 0;
+}
+function getStreamKind(stream, std) {
+  if (stream == null) return "ignore";
+  if (stream !== std || !std.isTTY) return "pipe";
+  return stream;
+}
+class InParallelError extends Error {
+  constructor(causeResult, allResults) {
+    super(`"${causeResult.name}" exited with ${causeResult.code}.`);
+    __publicField(this, "code");
+    __publicField(this, "results");
+    this.name = causeResult.name;
+    this.code = causeResult.code;
+    this.results = allResults;
+  }
+}
+const noop = () => {
+};
+class MemoryWritable extends Writable {
+  constructor(data = null) {
+    super();
+    __publicField(this, "queue", []);
+    __publicField(this, "data");
+    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 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;
+  }
+}
+function removeFromArr(arr, item) {
+  const index = arr.indexOf(item);
+  if (index !== -1) {
+    arr.splice(index, 1);
+  }
+}
+function crossSpawnPromise(cmd, args = [], options = {}) {
+  return new Promise((resolve, reject) => {
+    let stdout = "";
+    let stderr = "";
+    const ch = spawn$1(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);
+    });
+  });
+}
+async function killPids(pid, platform = process.platform) {
+  if (platform === "win32") {
+    spawn$1("taskkill", ["/F", "/T", "/PID", String(pid)]);
+    return;
+  }
+  try {
+    let stdout = await crossSpawnPromise("ps", ["-A", "-o", "ppid,pid"]);
+    let stdoutRows = stdout.split(os.EOL);
+    let pidExists = false;
+    const pidTree = {};
+    for (let i = 1; i < stdoutRows.length; i++) {
+      stdoutRows[i] = stdoutRows[i].trim();
+      if (!stdoutRows[i]) continue;
+      let stdoutTuple = stdoutRows[i].split(/\s+/);
+      let stdoutPpid = parseInt(stdoutTuple[0], 10);
+      let 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) {
+      let 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 pid2 of pids) {
+      process.kill(pid2);
+    }
+  } catch (err) {
+  }
+}
+function spawn(command, args, options) {
+  const child = spawn$1(command, args, options);
+  child.kill = function kill() {
+    killPids(this.pid);
+    return true;
+  };
+  return child;
+}
+let FORCE_COLOR;
+let NODE_DISABLE_COLORS;
+let NO_COLOR;
+let TERM;
+let isTTY = true;
+let enabled;
+function checkColorSupport() {
+  if (enabled != null) return;
+  ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env);
+  isTTY = process.stdout && process.stdout.isTTY;
+  enabled = !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY);
+}
+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;
+  };
+}
+const colors = [
+  createColor(36, 39),
+  // cyan
+  createColor(32, 39),
+  // green
+  createColor(35, 39),
+  // magenta
+  createColor(33, 39),
+  // yellow
+  createColor(31, 39)
+  // red
+];
+let colorIndex = 0;
+const taskNamesToColors = /* @__PURE__ */ new Map();
+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;
+}
+const ALL_BR = /\n/g;
+class PrefixTransform extends Transform {
+  constructor(prefix) {
+    super();
+    __publicField(this, "prefix");
+    __publicField(this, "lastPrefix");
+    __publicField(this, "lastIsLinebreak");
+    this.prefix = prefix;
+    this.lastPrefix = null;
+    this.lastIsLinebreak = true;
+  }
+  _transform(chunk, _enc, cb) {
+    const firstPrefix = this.lastIsLinebreak ? this.prefix : this.lastPrefix !== this.prefix ? "\n" : "";
+    const prefixed = `${firstPrefix}${chunk}`.replace(
+      ALL_BR,
+      `
+${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);
+  }
+}
+function wrapStreamWithLabel(source, label) {
+  if (source == null) return source;
+  const color = source.isTTY ? selectColor(label) : (x) => x;
+  const prefix = color(`[${label}] `);
+  const target = new PrefixTransform(prefix);
+  target.pipe(source);
+  return target;
+}
+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();
+    }
+  });
+}
+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;
+}
+async function run(argv) {
+  const require2 = createRequire(import.meta.url);
+  const packageJson = require2("../package.json");
+  process.stdout.setMaxListeners(0);
+  process.stderr.setMaxListeners(0);
+  process.stdin.setMaxListeners(0);
+  sade("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);

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+
+declare interface Options {
+    _: string[];
+    names?: string;
+    'aggregate-output'?: boolean;
+    'continue-on-error'?: boolean;
+    'max-parallel'?: number;
+}
+
+/**
+ * prog represents the main program logic.
+ */
+export declare function prog(opts: Options, proc: NodeJS.Process): Promise<unknown>;
+
+export { }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "in-parallel-lit",
   "description": "Run multiple processes in parallel",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "author": "Joel Voss <mail@joelvoss.com>",
   "license": "MIT",
   "homepage": "https://github.com/joelvoss/in-parallel-lit",
@@ -12,21 +12,30 @@
     "type": "git",
     "url": "git+https://github.com/joelvoss/in-parallel-lit.git"
   },
-  "type": "module",
   "engines": {
     "node": ">=18"
   },
-  "main": "src/index.js",
   "bin": {
-    "in-parallel": "src/bin.js"
+    "in-parallel": "dist/bin.js"
   },
+  "type": "module",
   "files": [
-    "src",
-    "LICENSE"
+    "dist",
+    "LICENSE",
+    "README.md"
   ],
+  "source": "./src/bin.ts",
+  "main": "./dist/bin.cjs",
+  "module": "./dist/bin.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "import": "./dist/bin.js",
+    "require": "./dist/bin.cjs"
+  },
   "scripts": {
-    "start": "./Taskfile.sh start",
-    "test": "./Taskfile.sh test"
+    "test": "./Taskfile.sh test",
+    "prepublishOnly": "./Taskfile.sh build"
   },
   "dependencies": {
     "cross-spawn": "^7.0.3",
@@ -34,18 +43,19 @@
     "sade": "^1.8.1"
   },
   "devDependencies": {
-    "@jvdx/core": "^3.6.0"
+    "@jvdx/eslint-config": "^4.3.0",
+    "@jvdx/prettier-config": "^0.3.4",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/node": "^20.14.5",
+    "prettier": "^3.3.2",
+    "typescript": "^5.4.5",
+    "vite": "^5.3.1",
+    "vite-plugin-dts": "^3.9.1",
+    "vitest": "^1.6.0"
   },
   "prettier": "@jvdx/prettier-config",
   "prettierIgnore": [
     "tests/",
     "dist/"
-  ],
-  "eslintConfig": {
-    "extends": "@jvdx/eslint-config"
-  },
-  "eslintIgnore": [
-    "tests/",
-    "dist/"
   ]
 }

package/src/bin.js

@@ -1,42 +0,0 @@
-#!/usr/bin/env node
-
-import { createRequire } from 'module';
-import sade from 'sade';
-import { prog } from './index.js';
-
-async function run(argv) {
-	const require = createRequire(import.meta.url);
-	const packageJson = require('../package.json');
-
-	// NOTE(joel): Avoid `MaxListenersExceededWarnings`.
-	process.stdout.setMaxListeners(0);
-	process.stderr.setMaxListeners(0);
-	process.stdin.setMaxListeners(0);
-
-	sade('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);