concurrently 6.5.1 → 7.0.0

package/dist/src/command.d.ts

@@ -0,0 +1,101 @@
+/// <reference types="node" />
+import { ChildProcess as BaseChildProcess, SpawnOptions } from 'child_process';
+import * as Rx from 'rxjs';
+import { EventEmitter, Writable } from 'stream';
+/**
+ * Identifier for a command; if string, it's the command's name, if number, it's the index.
+ */
+export declare type CommandIdentifier = string | number;
+export interface CommandInfo {
+    /**
+     * Command's name.
+     */
+    name: string;
+    /**
+     * Which command line the command has.
+     */
+    command: string;
+    /**
+     * Which environment variables should the spawned process have.
+     */
+    env?: Record<string, any>;
+    /**
+     * The current working directory of the process when spawned.
+     */
+    cwd?: string;
+    prefixColor?: string;
+}
+export interface CloseEvent {
+    command: CommandInfo;
+    /**
+     * The command's index among all commands ran.
+     */
+    index: number;
+    /**
+     * Whether the command exited because it was killed.
+     */
+    killed: boolean;
+    /**
+     * The exit code or signal for the command.
+     */
+    exitCode: string | number;
+    timings: {
+        startDate: Date;
+        endDate: Date;
+        durationSeconds: number;
+    };
+}
+export interface TimerEvent {
+    startDate: Date;
+    endDate?: Date;
+}
+/**
+ * Subtype of NodeJS's child_process including only what's actually needed for a command to work.
+ */
+export declare type ChildProcess = EventEmitter & Pick<BaseChildProcess, 'pid' | 'stdin' | 'stdout' | 'stderr'>;
+/**
+ * Interface for a function that must kill the process with `pid`, optionally sending `signal` to it.
+ */
+export declare type KillProcess = (pid: number, signal?: string) => void;
+/**
+ * Interface for a function that spawns a command and returns its child process instance.
+ */
+export declare type SpawnCommand = (command: string, options: SpawnOptions) => ChildProcess;
+export declare class Command implements CommandInfo {
+    private readonly killProcess;
+    private readonly spawn;
+    private readonly spawnOpts;
+    readonly index: number;
+    /** @inheritdoc */
+    readonly name: string;
+    /** @inheritdoc */
+    readonly command: string;
+    /** @inheritdoc */
+    readonly prefixColor: string;
+    /** @inheritdoc */
+    readonly env: Record<string, any>;
+    /** @inheritdoc */
+    readonly cwd?: string;
+    readonly close: Rx.Subject<CloseEvent>;
+    readonly error: Rx.Subject<unknown>;
+    readonly stdout: Rx.Subject<Buffer>;
+    readonly stderr: Rx.Subject<Buffer>;
+    readonly timer: Rx.Subject<TimerEvent>;
+    process?: ChildProcess;
+    stdin?: Writable;
+    pid?: number;
+    killed: boolean;
+    exited: boolean;
+    get killable(): boolean;
+    constructor({ index, name, command, prefixColor, env, cwd }: CommandInfo & {
+        index: number;
+    }, spawnOpts: SpawnOptions, spawn: SpawnCommand, killProcess: KillProcess);
+    /**
+     * Starts this command, piping output, error and close events onto the corresponding observables.
+     */
+    start(): void;
+    /**
+     * Kills this command, optionally specifying a signal to send to it.
+     */
+    kill(code?: string): void;
+}

package/{src → dist/src}/command.js

@@ -1,54 +1,72 @@
-const Rx = require('rxjs');
-
-module.exports = class Command {
-    get killable() {
-        return !!this.process;
-    }
-
-    constructor({ index, name, command, prefixColor, env, killProcess, spawn, spawnOpts }) {
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
+const Rx = __importStar(require("rxjs"));
+class Command {
+    constructor({ index, name, command, prefixColor, env, cwd }, spawnOpts, spawn, killProcess) {
+        this.close = new Rx.Subject();
+        this.error = new Rx.Subject();
+        this.stdout = new Rx.Subject();
+        this.stderr = new Rx.Subject();
+        this.timer = new Rx.Subject();
+        this.killed = false;
+        this.exited = false;
         this.index = index;
         this.name = name;
         this.command = command;
         this.prefixColor = prefixColor;
         this.env = env;
+        this.cwd = cwd;
         this.killProcess = killProcess;
         this.spawn = spawn;
         this.spawnOpts = spawnOpts;
-        this.killed = false;
-
-        this.error = new Rx.Subject();
-        this.timer = new Rx.Subject();
-        this.close = new Rx.Subject();
-        this.stdout = new Rx.Subject();
-        this.stderr = new Rx.Subject();
     }
-
+    get killable() {
+        return !!this.process;
+    }
+    /**
+     * Starts this command, piping output, error and close events onto the corresponding observables.
+     */
     start() {
         const child = this.spawn(this.command, this.spawnOpts);
         this.process = child;
         this.pid = child.pid;
         const startDate = new Date(Date.now());
         const highResStartTime = process.hrtime();
-        this.timer.next({startDate});
-
+        this.timer.next({ startDate });
         Rx.fromEvent(child, 'error').subscribe(event => {
             this.process = undefined;
             const endDate = new Date(Date.now());
-            this.timer.next({startDate, endDate});
+            this.timer.next({ startDate, endDate });
             this.error.next(event);
         });
         Rx.fromEvent(child, 'close').subscribe(([exitCode, signal]) => {
             this.process = undefined;
+            this.exited = true;
             const endDate = new Date(Date.now());
-            this.timer.next({startDate, endDate});
+            this.timer.next({ startDate, endDate });
             const [durationSeconds, durationNanoSeconds] = process.hrtime(highResStartTime);
             this.close.next({
-                command: {
-                    command: this.command,
-                    name: this.name,
-                    prefixColor: this.prefixColor,
-                    env: this.env,
-                },
+                command: this,
                 index: this.index,
                 exitCode: exitCode === null ? signal : exitCode,
                 killed: this.killed,
@@ -63,15 +81,21 @@ module.exports = class Command {
         child.stderr && pipeTo(Rx.fromEvent(child.stderr, 'data'), this.stderr);
         this.stdin = child.stdin;
     }
-
+    /**
+     * Kills this command, optionally specifying a signal to send to it.
+     */
     kill(code) {
         if (this.killable) {
             this.killed = true;
             this.killProcess(this.pid, code);
         }
     }
-};
-
+}
+exports.Command = Command;
+;
+/**
+ * Pipes all events emitted by `stream` into `subject`.
+ */
 function pipeTo(stream, subject) {
     stream.subscribe(event => subject.next(event));
 }

package/dist/src/command.spec.d.ts

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

package/dist/src/completion-listener.d.ts

@@ -0,0 +1,37 @@
+import * as Rx from 'rxjs';
+import { CloseEvent, Command } from './command';
+/**
+ * Defines which command(s) in a list must exit successfully (with an exit code of `0`):
+ *
+ * - `first`: only the first specified command;
+ * - `last`: only the last specified command;
+ * - `all`: all commands.
+ */
+export declare type SuccessCondition = 'first' | 'last' | 'all';
+/**
+ * Provides logic to determine whether lists of commands ran successfully.
+*/
+export declare class CompletionListener {
+    private readonly successCondition;
+    private readonly scheduler?;
+    constructor({ successCondition, scheduler }: {
+        /**
+         * How this instance will define that a list of commands ran successfully.
+         * Defaults to `all`.
+         *
+         * @see {SuccessCondition}
+         */
+        successCondition?: SuccessCondition;
+        /**
+         * For testing only.
+         */
+        scheduler?: Rx.SchedulerLike;
+    });
+    private isSuccess;
+    /**
+     * Given a list of commands, wait for all of them to exit and then evaluate their exit codes.
+     *
+     * @returns A Promise that resolves if the success condition is met, or rejects otherwise.
+     */
+    listen(commands: Command[]): Promise<CloseEvent[]>;
+}

package/dist/src/completion-listener.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompletionListener = void 0;
+const Rx = __importStar(require("rxjs"));
+const operators_1 = require("rxjs/operators");
+/**
+ * Provides logic to determine whether lists of commands ran successfully.
+*/
+class CompletionListener {
+    constructor({ successCondition = 'all', scheduler }) {
+        this.successCondition = successCondition;
+        this.scheduler = scheduler;
+    }
+    isSuccess(exitCodes) {
+        switch (this.successCondition) {
+            /* eslint-disable indent */
+            case 'first':
+                return exitCodes[0] === 0;
+            case 'last':
+                return exitCodes[exitCodes.length - 1] === 0;
+            default:
+                return exitCodes.every(exitCode => exitCode === 0);
+            /* eslint-enable indent */
+        }
+    }
+    /**
+     * Given a list of commands, wait for all of them to exit and then evaluate their exit codes.
+     *
+     * @returns A Promise that resolves if the success condition is met, or rejects otherwise.
+     */
+    listen(commands) {
+        const closeStreams = commands.map(command => command.close);
+        return Rx.merge(...closeStreams)
+            .pipe((0, operators_1.bufferCount)(closeStreams.length), (0, operators_1.switchMap)(exitInfos => this.isSuccess(exitInfos.map(({ exitCode }) => exitCode))
+            ? Rx.of(exitInfos, this.scheduler)
+            : Rx.throwError(exitInfos, this.scheduler)), (0, operators_1.take)(1))
+            .toPromise();
+    }
+}
+exports.CompletionListener = CompletionListener;
+;

package/dist/src/completion-listener.spec.d.ts

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

package/dist/src/concurrently.d.ts

@@ -0,0 +1,77 @@
+/// <reference types="node" />
+import { Writable } from 'stream';
+import { CloseEvent, Command, CommandInfo, KillProcess, SpawnCommand } from './command';
+import { SuccessCondition } from './completion-listener';
+import { FlowController } from './flow-control/flow-controller';
+import { Logger } from './logger';
+/**
+ * A command that is to be passed into `concurrently()`.
+ * If value is a string, then that's the command's command line.
+ * Fine grained options can be defined by using the object format.
+ */
+export declare type ConcurrentlyCommandInput = string | Partial<CommandInfo>;
+export declare type ConcurrentlyResult = {
+    /**
+     * All commands created and ran by concurrently.
+     */
+    commands: Command[];
+    /**
+     * A promise that resolves when concurrently ran successfully according to the specified
+     * success condition, or reject otherwise.
+     *
+     * Both the resolved and rejected value is the list of all command's close events.
+     */
+    result: Promise<CloseEvent[]>;
+};
+export declare type ConcurrentlyOptions = {
+    logger?: Logger;
+    /**
+     * Which stream should the commands output be written to.
+     */
+    outputStream?: Writable;
+    group?: boolean;
+    prefixColors?: string[];
+    /**
+     * Maximum number of commands to run at once.
+     *
+     * If undefined, then all processes will start in parallel.
+     * Setting this value to 1 will achieve sequential running.
+     */
+    maxProcesses?: number;
+    /**
+     * Whether commands should be spawned in raw mode.
+     * Defaults to false.
+     */
+    raw?: boolean;
+    /**
+     * The current working directory of commands which didn't specify one.
+     * Defaults to `process.cwd()`.
+     */
+    cwd?: string;
+    /**
+     * @see CompletionListener
+     */
+    successCondition?: SuccessCondition;
+    /**
+     * Which flow controllers should be applied on commands spawned by concurrently.
+     * Defaults to an empty array.
+     */
+    controllers: FlowController[];
+    /**
+     * A function that will spawn commands.
+     * Defaults to the `spawn-command` module.
+     */
+    spawn: SpawnCommand;
+    /**
+     * A function that will kill processes.
+     * Defaults to the `tree-kill` module.
+     */
+    kill: KillProcess;
+};
+/**
+ * Core concurrently functionality -- spawns the given commands concurrently and
+ * returns the commands themselves + the result according to the specified success condition.
+ *
+ * @see CompletionListener
+ */
+export declare function concurrently(baseCommands: ConcurrentlyCommandInput[], baseOptions?: Partial<ConcurrentlyOptions>): ConcurrentlyResult;

package/dist/src/concurrently.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concurrently = void 0;
+const assert_1 = __importDefault(require("assert"));
+const lodash_1 = __importDefault(require("lodash"));
+const spawn_command_1 = __importDefault(require("spawn-command"));
+const tree_kill_1 = __importDefault(require("tree-kill"));
+const command_1 = require("./command");
+const expand_npm_shortcut_1 = require("./command-parser/expand-npm-shortcut");
+const expand_npm_wildcard_1 = require("./command-parser/expand-npm-wildcard");
+const strip_quotes_1 = require("./command-parser/strip-quotes");
+const completion_listener_1 = require("./completion-listener");
+const get_spawn_opts_1 = require("./get-spawn-opts");
+const output_writer_1 = require("./output-writer");
+const defaults = {
+    spawn: spawn_command_1.default,
+    kill: tree_kill_1.default,
+    raw: false,
+    controllers: [],
+    cwd: undefined,
+};
+/**
+ * Core concurrently functionality -- spawns the given commands concurrently and
+ * returns the commands themselves + the result according to the specified success condition.
+ *
+ * @see CompletionListener
+ */
+function concurrently(baseCommands, baseOptions) {
+    assert_1.default.ok(Array.isArray(baseCommands), '[concurrently] commands should be an array');
+    assert_1.default.notStrictEqual(baseCommands.length, 0, '[concurrently] no commands provided');
+    const options = lodash_1.default.defaults(baseOptions, defaults);
+    const commandParsers = [
+        new strip_quotes_1.StripQuotes(),
+        new expand_npm_shortcut_1.ExpandNpmShortcut(),
+        new expand_npm_wildcard_1.ExpandNpmWildcard()
+    ];
+    let lastColor = '';
+    let commands = (0, lodash_1.default)(baseCommands)
+        .map(mapToCommandInfo)
+        .flatMap(command => parseCommand(command, commandParsers))
+        .map((command, index) => {
+        // Use documented behaviour of repeating last color when specifying more commands than colors
+        lastColor = options.prefixColors && options.prefixColors[index] || lastColor;
+        return new command_1.Command(Object.assign({
+            index,
+            prefixColor: lastColor,
+        }, command), (0, get_spawn_opts_1.getSpawnOpts)({
+            raw: options.raw,
+            env: command.env,
+            cwd: command.cwd || options.cwd,
+        }), options.spawn, options.kill);
+    })
+        .value();
+    const handleResult = options.controllers.reduce(({ commands: prevCommands, onFinishCallbacks }, controller) => {
+        const { commands, onFinish } = controller.handle(prevCommands);
+        return {
+            commands,
+            onFinishCallbacks: lodash_1.default.concat(onFinishCallbacks, onFinish ? [onFinish] : [])
+        };
+    }, { commands, onFinishCallbacks: [] });
+    commands = handleResult.commands;
+    if (options.logger) {
+        const outputWriter = new output_writer_1.OutputWriter({
+            outputStream: options.outputStream,
+            group: options.group,
+            commands,
+        });
+        options.logger.output.subscribe(({ command, text }) => outputWriter.write(command, text));
+    }
+    const commandsLeft = commands.slice();
+    const maxProcesses = Math.max(1, Number(options.maxProcesses) || commandsLeft.length);
+    for (let i = 0; i < maxProcesses; i++) {
+        maybeRunMore(commandsLeft);
+    }
+    const result = new completion_listener_1.CompletionListener({ successCondition: options.successCondition })
+        .listen(commands)
+        .finally(() => {
+        handleResult.onFinishCallbacks.forEach((onFinish) => onFinish());
+    });
+    return {
+        result,
+        commands,
+    };
+}
+exports.concurrently = concurrently;
+;
+function mapToCommandInfo(command) {
+    if (typeof command === 'string') {
+        return {
+            command,
+            name: '',
+            env: {},
+            cwd: '',
+        };
+    }
+    return Object.assign({
+        command: command.command,
+        name: command.name || '',
+        env: command.env || {},
+        cwd: command.cwd || '',
+    }, command.prefixColor ? {
+        prefixColor: command.prefixColor,
+    } : {});
+}
+function parseCommand(command, parsers) {
+    return parsers.reduce((commands, parser) => lodash_1.default.flatMap(commands, command => parser.parse(command)), lodash_1.default.castArray(command));
+}
+function maybeRunMore(commandsLeft) {
+    const command = commandsLeft.shift();
+    if (!command) {
+        return;
+    }
+    command.start();
+    command.close.subscribe(() => {
+        maybeRunMore(commandsLeft);
+    });
+}

package/dist/src/concurrently.spec.d.ts

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

package/dist/src/defaults.d.ts

@@ -0,0 +1,52 @@
+import { SuccessCondition } from './completion-listener';
+export declare const defaultInputTarget = 0;
+/**
+ * Whether process.stdin should be forwarded to child processes
+ */
+export declare const handleInput = false;
+/**
+ * How many processes to run at once.
+ */
+export declare const maxProcesses = 0;
+export declare const hide = "";
+export declare const nameSeparator = ",";
+/**
+ * Which prefix style to use when logging processes output.
+ */
+export declare const prefix = "";
+/**
+ * Default prefix color.
+ * @see https://www.npmjs.com/package/chalk
+ */
+export declare const prefixColors = "reset";
+/**
+ * How many bytes we'll show on the command prefix
+ */
+export declare const prefixLength = 10;
+export declare const raw = false;
+/**
+ * Number of attempts of restarting a process, if it exits with non-0 code
+ */
+export declare const restartTries = 0;
+/**
+ * How many milliseconds concurrently should wait before restarting a process.
+ */
+export declare const restartDelay = 0;
+/**
+ * Condition of success for concurrently itself.
+ */
+export declare const success: SuccessCondition;
+/**
+ * Date format used when logging date/time.
+ * @see https://date-fns.org/v2.0.1/docs/format
+ */
+export declare const timestampFormat = "yyyy-MM-dd HH:mm:ss.SSS";
+/**
+ * Current working dir passed as option to spawn command.
+ * Defaults to process.cwd()
+ */
+export declare const cwd: string | undefined;
+/**
+ * Whether to show timing information for processes in console output
+ */
+export declare const timings = false;

package/dist/src/defaults.js

@@ -0,0 +1,58 @@
+"use strict";
+// This file is meant to be a shared place for default configs.
+// It's read by the flow controllers, the executable, etc.
+// Refer to tests for the meaning of the different possible values.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timings = exports.cwd = exports.timestampFormat = exports.success = exports.restartDelay = exports.restartTries = exports.raw = exports.prefixLength = exports.prefixColors = exports.prefix = exports.nameSeparator = exports.hide = exports.maxProcesses = exports.handleInput = exports.defaultInputTarget = void 0;
+exports.defaultInputTarget = 0;
+/**
+ * Whether process.stdin should be forwarded to child processes
+ */
+exports.handleInput = false;
+/**
+ * How many processes to run at once.
+ */
+exports.maxProcesses = 0;
+// Indices and names of commands whose output are not to be logged
+exports.hide = '';
+exports.nameSeparator = ',';
+/**
+ * Which prefix style to use when logging processes output.
+ */
+exports.prefix = '';
+/**
+ * Default prefix color.
+ * @see https://www.npmjs.com/package/chalk
+ */
+exports.prefixColors = 'reset';
+/**
+ * How many bytes we'll show on the command prefix
+ */
+exports.prefixLength = 10;
+exports.raw = false;
+/**
+ * Number of attempts of restarting a process, if it exits with non-0 code
+ */
+exports.restartTries = 0;
+/**
+ * How many milliseconds concurrently should wait before restarting a process.
+ */
+exports.restartDelay = 0;
+/**
+ * Condition of success for concurrently itself.
+ */
+exports.success = 'all';
+/**
+ * Date format used when logging date/time.
+ * @see https://date-fns.org/v2.0.1/docs/format
+ */
+exports.timestampFormat = 'yyyy-MM-dd HH:mm:ss.SSS';
+/**
+ * Current working dir passed as option to spawn command.
+ * Defaults to process.cwd()
+ */
+exports.cwd = undefined;
+/**
+ * Whether to show timing information for processes in console output
+ */
+exports.timings = false;

package/dist/src/flow-control/flow-controller.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '../command';
+/**
+ * Interface for a class that controls and/or watches the behavior of commands.
+ *
+ * This may include logging their output, creating interactions between them, or changing when they
+ * actually finish.
+ */
+export interface FlowController {
+    handle(commands: Command[]): {
+        commands: Command[];
+        onFinish?: () => void;
+    };
+}

package/dist/src/flow-control/flow-controller.js

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