concurrently 6.5.1 → 7.2.0

package/dist/src/command-parser/expand-npm-shortcut.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpandNpmShortcut = void 0;
+/**
+ * Expands commands prefixed with `npm:`, `yarn:` or `pnpm:` into the full version `npm run <command>` and so on.
+ */
+class ExpandNpmShortcut {
+    parse(commandInfo) {
+        const [, npmCmd, cmdName, args] = commandInfo.command.match(/^(npm|yarn|pnpm):(\S+)(.*)/) || [];
+        if (!cmdName) {
+            return commandInfo;
+        }
+        return Object.assign({}, commandInfo, {
+            name: commandInfo.name || cmdName,
+            command: `${npmCmd} run ${cmdName}${args}`,
+        });
+    }
+}
+exports.ExpandNpmShortcut = ExpandNpmShortcut;
+;

package/dist/src/command-parser/expand-npm-wildcard.d.ts

@@ -0,0 +1,13 @@
+import { CommandInfo } from '../command';
+import { CommandParser } from './command-parser';
+/**
+ * Finds wildcards in npm/yarn/pnpm run commands and replaces them with all matching scripts in the
+ * `package.json` file of the current directory.
+ */
+export declare class ExpandNpmWildcard implements CommandParser {
+    private readonly readPackage;
+    static readPackage(): any;
+    private scripts?;
+    constructor(readPackage?: typeof ExpandNpmWildcard.readPackage);
+    parse(commandInfo: CommandInfo): CommandInfo | CommandInfo[];
+}

package/dist/src/command-parser/expand-npm-wildcard.js

@@ -0,0 +1,82 @@
+"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.ExpandNpmWildcard = void 0;
+const fs = __importStar(require("fs"));
+const _ = __importStar(require("lodash"));
+const OMISSION = /\(!([^\)]+)\)/;
+/**
+ * Finds wildcards in npm/yarn/pnpm run commands and replaces them with all matching scripts in the
+ * `package.json` file of the current directory.
+ */
+class ExpandNpmWildcard {
+    constructor(readPackage = ExpandNpmWildcard.readPackage) {
+        this.readPackage = readPackage;
+    }
+    static readPackage() {
+        try {
+            const json = fs.readFileSync('package.json', { encoding: 'utf-8' });
+            return JSON.parse(json);
+        }
+        catch (e) {
+            return {};
+        }
+    }
+    parse(commandInfo) {
+        const [, npmCmd, cmdName, args] = commandInfo.command.match(/(npm|yarn|pnpm) run (\S+)([^&]*)/) || [];
+        const wildcardPosition = (cmdName || '').indexOf('*');
+        // If the regex didn't match an npm script, or it has no wildcard,
+        // then we have nothing to do here
+        if (!cmdName || wildcardPosition === -1) {
+            return commandInfo;
+        }
+        if (!this.scripts) {
+            this.scripts = Object.keys(this.readPackage().scripts || {});
+        }
+        const omissionRegex = cmdName.match(OMISSION);
+        const cmdNameSansOmission = cmdName.replace(OMISSION, '');
+        const preWildcard = _.escapeRegExp(cmdNameSansOmission.substr(0, wildcardPosition));
+        const postWildcard = _.escapeRegExp(cmdNameSansOmission.substr(wildcardPosition + 1));
+        const wildcardRegex = new RegExp(`^${preWildcard}(.*?)${postWildcard}$`);
+        const currentName = commandInfo.name || '';
+        return this.scripts
+            .map(script => {
+            const match = script.match(wildcardRegex);
+            if (omissionRegex) {
+                const toOmit = script.match(new RegExp(omissionRegex[1]));
+                if (toOmit) {
+                    return;
+                }
+            }
+            if (match) {
+                return Object.assign({}, commandInfo, {
+                    command: `${npmCmd} run ${script}${args}`,
+                    // Will use an empty command name if command has no name and the wildcard match is empty,
+                    // e.g. if `npm:watch-*` matches `npm run watch-`.
+                    name: currentName + match[1],
+                });
+            }
+        })
+            .filter((commandInfo) => !!commandInfo);
+    }
+}
+exports.ExpandNpmWildcard = ExpandNpmWildcard;
+;

package/dist/src/command-parser/strip-quotes.d.ts

@@ -0,0 +1,10 @@
+import { CommandInfo } from '../command';
+import { CommandParser } from './command-parser';
+/**
+ * Strips quotes around commands so that they can run on the current shell.
+ */
+export declare class StripQuotes implements CommandParser {
+    parse(commandInfo: CommandInfo): CommandInfo & {
+        command: string;
+    };
+}

package/dist/src/command-parser/strip-quotes.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StripQuotes = void 0;
+/**
+ * Strips quotes around commands so that they can run on the current shell.
+ */
+class StripQuotes {
+    parse(commandInfo) {
+        let { command } = commandInfo;
+        // Removes the quotes surrounding a command.
+        if (/^"(.+?)"$/.test(command) || /^'(.+?)'$/.test(command)) {
+            command = command.substring(1, command.length - 1);
+        }
+        return Object.assign({}, commandInfo, { command });
+    }
+}
+exports.StripQuotes = StripQuotes;
+;

package/dist/src/command.d.ts

@@ -0,0 +1,104 @@
+/// <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;
+    /**
+     * Color to use on prefix of command.
+     */
+    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,
@@ -56,22 +74,28 @@ module.exports = class Command {
                     startDate,
                     endDate,
                     durationSeconds: durationSeconds + (durationNanoSeconds / 1e9),
-                }
+                },
             });
         });
         child.stdout && pipeTo(Rx.fromEvent(child.stdout, 'data'), this.stdout);
         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/completion-listener.d.ts

@@ -0,0 +1,39 @@
+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.
+ * - `command-{name|index}`: only the commands with the specified names or index.
+ * - `!command-{name|index}`: all commands but the ones with the specified names or index.
+ */
+export declare type SuccessCondition = 'first' | 'last' | 'all' | `command-${string | number}` | `!command-${string | number}`;
+/**
+ * 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,74 @@
+"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(events) {
+        if (this.successCondition === 'first') {
+            return events[0].exitCode === 0;
+        }
+        else if (this.successCondition === 'last') {
+            return events[events.length - 1].exitCode === 0;
+        }
+        else if (!/^!?command-.+$/.test(this.successCondition)) {
+            // If not a `command-` syntax, then it's an 'all' condition or it's treated as such.
+            return events.every(({ exitCode }) => exitCode === 0);
+        }
+        // Check `command-` syntax condition.
+        // Note that a command's `name` is not necessarily unique,
+        // in which case all of them must meet the success condition.
+        const [, nameOrIndex] = this.successCondition.split('-');
+        const targetCommandsEvents = events.filter(({ command, index }) => (command.name === nameOrIndex
+            || index === Number(nameOrIndex)));
+        if (this.successCondition.startsWith('!')) {
+            // All commands except the specified ones must exit succesfully
+            return events.every((event) => (targetCommandsEvents.includes(event)
+                || event.exitCode === 0));
+        }
+        // Only the specified commands must exit succesfully
+        return targetCommandsEvents.length > 0
+            && targetCommandsEvents.every(event => event.exitCode === 0);
+    }
+    /**
+     * 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)
+            ? Rx.of(exitInfos, this.scheduler)
+            : Rx.throwError(exitInfos, this.scheduler)), (0, operators_1.take)(1))
+            .toPromise();
+    }
+}
+exports.CompletionListener = CompletionListener;
+;

package/dist/src/concurrently.d.ts

@@ -0,0 +1,90 @@
+/// <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;
+    /**
+     * Whether the output should be ordered as if the commands were run sequentially.
+     */
+    group?: boolean;
+    /**
+     * Comma-separated list of chalk colors to use on prefixes.
+     */
+    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;
+    /**
+     * List of additional arguments passed that will get replaced in each command.
+     * If not defined, no argument replacing will happen.
+     *
+     * @see ExpandArguments
+     */
+    additionalArguments?: string[];
+};
+/**
+ * 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;