in-parallel-lit 0.4.0 → 2.0.0

package/README.md

@@ -2,16 +2,10 @@
 
 A CLI tool to run multiple processes in parallel.
 
-## Requirements
-
-- [Node v16+][install-node]
-
 ## Installation
 
 ```bash
 $ npm i -g in-parallel-lit
-# or
-$ yarn global add in-parallel-lit
 ```
 
 ## Usage
@@ -155,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,413 @@
+#!/usr/bin/env node
+"use strict";
+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);
+const node_module = require("node:module");
+const sade = require("sade");
+const node_stream = require("node:stream");
+const node_string_decoder = require("node:string_decoder");
+const crossSpawn = require("cross-spawn");
+const os = require("node:os");
+var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
+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 node_stream.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 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;
+  }
+}
+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 = crossSpawn.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);
+    });
+  });
+}
+async function killPids(pid, platform = process.platform) {
+  if (platform === "win32") {
+    crossSpawn.spawn("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 = crossSpawn.spawn(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 node_stream.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 require$1 = node_module.createRequire(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.src || new URL("bin.cjs", document.baseURI).href);
+  const packageJson = require$1("../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);