concurrently 6.3.0 → 7.0.0

package/dist/src/index.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestartProcess = exports.LogTimings = exports.LogOutput = exports.LogExit = exports.LogError = exports.KillOthers = exports.KillOnSignal = exports.InputHandler = exports.Command = exports.Logger = exports.concurrently = void 0;
+const command_1 = require("./command");
+Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return command_1.Command; } });
+const concurrently_1 = require("./concurrently");
+Object.defineProperty(exports, "concurrently", { enumerable: true, get: function () { return concurrently_1.concurrently; } });
+const input_handler_1 = require("./flow-control/input-handler");
+Object.defineProperty(exports, "InputHandler", { enumerable: true, get: function () { return input_handler_1.InputHandler; } });
+const kill_on_signal_1 = require("./flow-control/kill-on-signal");
+Object.defineProperty(exports, "KillOnSignal", { enumerable: true, get: function () { return kill_on_signal_1.KillOnSignal; } });
+const kill_others_1 = require("./flow-control/kill-others");
+Object.defineProperty(exports, "KillOthers", { enumerable: true, get: function () { return kill_others_1.KillOthers; } });
+const log_error_1 = require("./flow-control/log-error");
+Object.defineProperty(exports, "LogError", { enumerable: true, get: function () { return log_error_1.LogError; } });
+const log_exit_1 = require("./flow-control/log-exit");
+Object.defineProperty(exports, "LogExit", { enumerable: true, get: function () { return log_exit_1.LogExit; } });
+const log_output_1 = require("./flow-control/log-output");
+Object.defineProperty(exports, "LogOutput", { enumerable: true, get: function () { return log_output_1.LogOutput; } });
+const log_timings_1 = require("./flow-control/log-timings");
+Object.defineProperty(exports, "LogTimings", { enumerable: true, get: function () { return log_timings_1.LogTimings; } });
+const restart_process_1 = require("./flow-control/restart-process");
+Object.defineProperty(exports, "RestartProcess", { enumerable: true, get: function () { return restart_process_1.RestartProcess; } });
+const logger_1 = require("./logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
+exports.default = (commands, options = {}) => {
+    const logger = new logger_1.Logger({
+        hide: options.hide,
+        prefixFormat: options.prefix,
+        prefixLength: options.prefixLength,
+        raw: options.raw,
+        timestampFormat: options.timestampFormat,
+    });
+    return (0, concurrently_1.concurrently)(commands, {
+        maxProcesses: options.maxProcesses,
+        raw: options.raw,
+        successCondition: options.successCondition,
+        cwd: options.cwd,
+        logger,
+        outputStream: options.outputStream || process.stdout,
+        group: options.group,
+        controllers: [
+            new log_error_1.LogError({ logger }),
+            new log_output_1.LogOutput({ logger }),
+            new log_exit_1.LogExit({ logger }),
+            new input_handler_1.InputHandler({
+                logger,
+                defaultInputTarget: options.defaultInputTarget,
+                inputStream: options.inputStream || (options.handleInput && process.stdin),
+                pauseInputStreamOnFinish: options.pauseInputStreamOnFinish,
+            }),
+            new kill_on_signal_1.KillOnSignal({ process }),
+            new restart_process_1.RestartProcess({
+                logger,
+                delay: options.restartDelay,
+                tries: options.restartTries,
+            }),
+            new kill_others_1.KillOthers({
+                logger,
+                conditions: options.killOthers
+            }),
+            new log_timings_1.LogTimings({
+                logger: options.timings ? logger : null,
+                timestampFormat: options.timestampFormat,
+            })
+        ],
+        prefixColors: options.prefixColors || [],
+    });
+};

package/dist/src/logger.d.ts

@@ -0,0 +1,72 @@
+import * as Rx from 'rxjs';
+import { Command, CommandIdentifier } from './command';
+export declare class Logger {
+    private readonly hide;
+    private readonly raw;
+    private readonly prefixFormat?;
+    private readonly prefixLength;
+    private readonly timestampFormat;
+    /**
+     * Last character emitted.
+     * If `undefined`, then nothing has been logged yet.
+     */
+    private lastChar?;
+    /**
+     * Observable that emits when there's been output logged.
+     * If `command` is is `undefined`, then the log is for a global event.
+     */
+    readonly output: Rx.Subject<{
+        command: Command | undefined;
+        text: string;
+    }>;
+    constructor({ hide, prefixFormat, prefixLength, raw, timestampFormat }: {
+        /**
+         * Which command(s) should have their output hidden.
+         */
+        hide?: CommandIdentifier | CommandIdentifier[];
+        /**
+         * Whether output should be formatted to include prefixes and whether "event" logs will be
+         * logged.
+         */
+        raw?: boolean;
+        /**
+         * The prefix format to use when logging a command's output.
+         * Defaults to the command's index.
+         */
+        prefixFormat?: string;
+        /**
+         * How many characters should a prefix have at most, used when the prefix format is `command`.
+         */
+        prefixLength?: number;
+        /**
+         * Date format used when logging date/time.
+         * @see https://date-fns.org/v2.0.1/docs/format
+         */
+        timestampFormat?: string;
+    });
+    private shortenText;
+    private getPrefixesFor;
+    getPrefix(command: Command): string;
+    colorText(command: Command, text: string): string;
+    /**
+     * Logs an event for a command (e.g. start, stop).
+     *
+     * If raw mode is on, then nothing is logged.
+     */
+    logCommandEvent(text: string, command: Command): void;
+    logCommandText(text: string, command: Command): void;
+    /**
+     * Logs a global event (e.g. sending signals to processes).
+     *
+     * If raw mode is on, then nothing is logged.
+     */
+    logGlobalEvent(text: string): void;
+    /**
+     * Logs a table from an input object array, like `console.table`.
+     *
+     * Each row is a single input item, and they are presented in the input order.
+     */
+    logTable(tableContents: any[]): void;
+    log(prefix: string, text: string, command?: Command): void;
+    emit(command: Command | undefined, text: string): void;
+}

package/dist/src/logger.js

@@ -0,0 +1,199 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const lodash_1 = __importDefault(require("lodash"));
+const format_1 = __importDefault(require("date-fns/format"));
+const Rx = __importStar(require("rxjs"));
+const defaults = __importStar(require("./defaults"));
+class Logger {
+    constructor({ hide, prefixFormat, prefixLength, raw = false, timestampFormat }) {
+        /**
+         * Observable that emits when there's been output logged.
+         * If `command` is is `undefined`, then the log is for a global event.
+         */
+        this.output = new Rx.Subject();
+        // To avoid empty strings from hiding the output of commands that don't have a name,
+        // keep in the list of commands to hide only strings with some length.
+        // This might happen through the CLI when no `--hide` argument is specified, for example.
+        this.hide = lodash_1.default.castArray(hide).filter(name => name || name === 0).map(String);
+        this.raw = raw;
+        this.prefixFormat = prefixFormat;
+        this.prefixLength = prefixLength || defaults.prefixLength;
+        this.timestampFormat = timestampFormat || defaults.timestampFormat;
+    }
+    shortenText(text) {
+        if (!text || text.length <= this.prefixLength) {
+            return text;
+        }
+        const ellipsis = '..';
+        const prefixLength = this.prefixLength - ellipsis.length;
+        const endLength = Math.floor(prefixLength / 2);
+        const beginningLength = prefixLength - endLength;
+        const beginnning = text.substring(0, beginningLength);
+        const end = text.substring(text.length - endLength, text.length);
+        return beginnning + ellipsis + end;
+    }
+    getPrefixesFor(command) {
+        return {
+            pid: String(command.pid),
+            index: String(command.index),
+            name: command.name,
+            command: this.shortenText(command.command),
+            time: (0, format_1.default)(Date.now(), this.timestampFormat),
+        };
+    }
+    getPrefix(command) {
+        const prefix = this.prefixFormat || (command.name ? 'name' : 'index');
+        if (prefix === 'none') {
+            return '';
+        }
+        const prefixes = this.getPrefixesFor(command);
+        if (Object.keys(prefixes).includes(prefix)) {
+            return `[${prefixes[prefix]}]`;
+        }
+        return lodash_1.default.reduce(prefixes, (prev, val, key) => {
+            const keyRegex = new RegExp(lodash_1.default.escapeRegExp(`{${key}}`), 'g');
+            return prev.replace(keyRegex, String(val));
+        }, prefix);
+    }
+    colorText(command, text) {
+        let color;
+        if (command.prefixColor && command.prefixColor.startsWith('#')) {
+            color = chalk_1.default.hex(command.prefixColor);
+        }
+        else {
+            const defaultColor = lodash_1.default.get(chalk_1.default, defaults.prefixColors, chalk_1.default.reset);
+            color = lodash_1.default.get(chalk_1.default, command.prefixColor, defaultColor);
+        }
+        return color(text);
+    }
+    /**
+     * Logs an event for a command (e.g. start, stop).
+     *
+     * If raw mode is on, then nothing is logged.
+     */
+    logCommandEvent(text, command) {
+        if (this.raw) {
+            return;
+        }
+        this.logCommandText(chalk_1.default.reset(text) + '\n', command);
+    }
+    logCommandText(text, command) {
+        if (this.hide.includes(String(command.index)) || this.hide.includes(command.name)) {
+            return;
+        }
+        const prefix = this.colorText(command, this.getPrefix(command));
+        return this.log(prefix + (prefix ? ' ' : ''), text, command);
+    }
+    /**
+     * Logs a global event (e.g. sending signals to processes).
+     *
+     * If raw mode is on, then nothing is logged.
+     */
+    logGlobalEvent(text) {
+        if (this.raw) {
+            return;
+        }
+        this.log(chalk_1.default.reset('-->') + ' ', chalk_1.default.reset(text) + '\n');
+    }
+    /**
+     * Logs a table from an input object array, like `console.table`.
+     *
+     * Each row is a single input item, and they are presented in the input order.
+     */
+    logTable(tableContents) {
+        // For now, can only print array tables with some content.
+        if (this.raw || !Array.isArray(tableContents) || !tableContents.length) {
+            return;
+        }
+        let nextColIndex = 0;
+        const headers = {};
+        const contentRows = tableContents.map(row => {
+            const rowContents = [];
+            Object.keys(row).forEach((col) => {
+                if (!headers[col]) {
+                    headers[col] = {
+                        index: nextColIndex++,
+                        length: col.length,
+                    };
+                }
+                const colIndex = headers[col].index;
+                const formattedValue = String(row[col] == null ? '' : row[col]);
+                // Update the column length in case this rows value is longer than the previous length for the column.
+                headers[col].length = Math.max(formattedValue.length, headers[col].length);
+                rowContents[colIndex] = formattedValue;
+                return rowContents;
+            });
+            return rowContents;
+        });
+        const headersFormatted = Object
+            .keys(headers)
+            .map(header => header.padEnd(headers[header].length, ' '));
+        if (!headersFormatted.length) {
+            // No columns exist.
+            return;
+        }
+        const borderRowFormatted = headersFormatted.map(header => '─'.padEnd(header.length, '─'));
+        this.logGlobalEvent(`┌─${borderRowFormatted.join('─┬─')}─┐`);
+        this.logGlobalEvent(`│ ${headersFormatted.join(' │ ')} │`);
+        this.logGlobalEvent(`├─${borderRowFormatted.join('─┼─')}─┤`);
+        contentRows.forEach(contentRow => {
+            const contentRowFormatted = headersFormatted.map((header, colIndex) => {
+                // If the table was expanded after this row was processed, it won't have this column.
+                // Use an empty string in this case.
+                const col = contentRow[colIndex] || '';
+                return col.padEnd(header.length, ' ');
+            });
+            this.logGlobalEvent(`│ ${contentRowFormatted.join(' │ ')} │`);
+        });
+        this.logGlobalEvent(`└─${borderRowFormatted.join('─┴─')}─┘`);
+    }
+    log(prefix, text, command) {
+        if (this.raw) {
+            return this.emit(command, text);
+        }
+        // #70 - replace some ANSI code that would impact clearing lines
+        text = text.replace(/\u2026/g, '...');
+        const lines = text.split('\n').map((line, index, lines) => {
+            // First line will write prefix only if we finished the last write with a LF.
+            // Last line won't write prefix because it should be empty.
+            if (index === 0 || index === lines.length - 1) {
+                return line;
+            }
+            return prefix + line;
+        });
+        if (!this.lastChar || this.lastChar === '\n') {
+            this.emit(command, prefix);
+        }
+        this.lastChar = text[text.length - 1];
+        this.emit(command, lines.join('\n'));
+    }
+    emit(command, text) {
+        this.output.next({ command, text });
+    }
+}
+exports.Logger = Logger;
+;

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

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

package/dist/src/output-writer.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { Writable } from 'stream';
+import { Command } from './command';
+/**
+ * Class responsible for actually writing output onto a writable stream.
+ */
+export declare class OutputWriter {
+    private readonly outputStream;
+    private readonly group;
+    readonly buffers: string[][];
+    activeCommandIndex: number;
+    constructor({ outputStream, group, commands }: {
+        outputStream: Writable;
+        group: boolean;
+        commands: Command[];
+    });
+    write(command: Command | undefined, text: string): void;
+    private flushBuffer;
+}

package/dist/src/output-writer.js

@@ -0,0 +1,69 @@
+"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.OutputWriter = void 0;
+const Rx = __importStar(require("rxjs"));
+/**
+ * Class responsible for actually writing output onto a writable stream.
+ */
+class OutputWriter {
+    constructor({ outputStream, group, commands }) {
+        this.activeCommandIndex = 0;
+        this.outputStream = outputStream;
+        this.group = group;
+        this.buffers = commands.map(() => []);
+        if (this.group) {
+            Rx.merge(...commands.map(c => c.close))
+                .subscribe(command => {
+                if (command.index !== this.activeCommandIndex) {
+                    return;
+                }
+                for (let i = command.index + 1; i < commands.length; i++) {
+                    this.activeCommandIndex = i;
+                    this.flushBuffer(i);
+                    if (!commands[i].exited) {
+                        break;
+                    }
+                }
+            });
+        }
+    }
+    write(command, text) {
+        if (this.group && command) {
+            if (command.index <= this.activeCommandIndex) {
+                this.outputStream.write(text);
+            }
+            else {
+                this.buffers[command.index].push(text);
+            }
+        }
+        else {
+            // "global" logs (command=null) are output out of order
+            this.outputStream.write(text);
+        }
+    }
+    flushBuffer(index) {
+        this.buffers[index].forEach(t => this.outputStream.write(t));
+        this.buffers[index] = [];
+    }
+}
+exports.OutputWriter = OutputWriter;
+;

package/dist/src/output-writer.spec.d.ts

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

package/index.js

@@ -1,61 +1,7 @@
-const InputHandler = require('./src/flow-control/input-handler');
-const KillOnSignal = require('./src/flow-control/kill-on-signal');
-const KillOthers = require('./src/flow-control/kill-others');
-const LogError = require('./src/flow-control/log-error');
-const LogExit = require('./src/flow-control/log-exit');
-const LogOutput = require('./src/flow-control/log-output');
-const RestartProcess = require('./src/flow-control/restart-process');
+//
+// While in local development, make sure you've run `npm run build` first.
+//
 
-const concurrently = require('./src/concurrently');
-const Logger = require('./src/logger');
-
-module.exports = exports = (commands, options = {}) => {
-    const logger = new Logger({
-        outputStream: options.outputStream || process.stdout,
-        prefixFormat: options.prefix,
-        prefixLength: options.prefixLength,
-        raw: options.raw,
-        timestampFormat: options.timestampFormat,
-    });
-
-    return concurrently(commands, {
-        maxProcesses: options.maxProcesses,
-        raw: options.raw,
-        successCondition: options.successCondition,
-        cwd: options.cwd,
-        controllers: [
-            new LogError({ logger }),
-            new LogOutput({ logger }),
-            new LogExit({ logger }),
-            new InputHandler({
-                logger,
-                defaultInputTarget: options.defaultInputTarget,
-                inputStream: options.inputStream || (options.handleInput && process.stdin),
-                pauseInputStreamOnFinish: options.pauseInputStreamOnFinish,
-            }),
-            new KillOnSignal({ process }),
-            new RestartProcess({
-                logger,
-                delay: options.restartDelay,
-                tries: options.restartTries,
-            }),
-            new KillOthers({
-                logger,
-                conditions: options.killOthers
-            })
-        ],
-        prefixColors: options.prefixColors || []
-    });
-};
-
-// Export all flow controllers and the main concurrently function,
-// so that 3rd-parties can use them however they want
-exports.concurrently = concurrently;
-exports.Logger = Logger;
-exports.InputHandler = InputHandler;
-exports.KillOnSignal = KillOnSignal;
-exports.KillOthers = KillOthers;
-exports.LogError = LogError;
-exports.LogExit = LogExit;
-exports.LogOutput = LogOutput;
-exports.RestartProcess = RestartProcess;
+const concurrently = require('./dist/src/index.js');
+module.exports = exports = concurrently.default;
+Object.assign(exports, concurrently);

package/index.mjs

@@ -0,0 +1,9 @@
+//
+// While in local development, make sure you've run `npm run build` first.
+//
+
+// NOTE: the star reexport doesn't work in Node <12.20, <14.13 and <15.
+export * from './dist/src/index.js';
+
+import concurrently from './dist/src/index.js';
+export default concurrently.default;

package/package.json

@@ -1,16 +1,27 @@
 {
   "name": "concurrently",
-  "version": "6.3.0",
+  "version": "7.0.0",
   "description": "Run commands concurrently",
   "main": "index.js",
+  "types": "dist/src/index.d.ts",
+  "type": "commonjs",
   "bin": {
-    "concurrently": "./bin/concurrently.js"
+    "concurrently": "./dist/bin/concurrently.js"
   },
   "engines": {
-    "node": ">=10.0.0"
+    "node": "^12.20.0 || ^14.13.0 || >=16.0.0"
+  },
+  "exports": {
+    "import": "./index.mjs",
+    "require": "./index.js",
+    "default": "./index.js"
   },
   "scripts": {
-    "lint": "eslint . --ignore-path .gitignore",
+    "build": "tsc --build",
+    "postbuild": "chmod +x dist/bin/concurrently.js",
+    "clean": "tsc --build --clean",
+    "lint": "eslint . --ext js,ts --ignore-path .gitignore",
+    "prepublishOnly": "npm run build",
     "report-coverage": "cat coverage/lcov.info | coveralls",
     "test": "jest"
   },
@@ -39,27 +50,42 @@
     "yargs": "^16.2.0"
   },
   "devDependencies": {
+    "@types/jest": "^27.0.3",
+    "@types/lodash": "^4.14.178",
+    "@types/node": "^17.0.0",
+    "@types/supports-color": "^8.1.1",
+    "@typescript-eslint/eslint-plugin": "^5.8.1",
+    "@typescript-eslint/parser": "^5.8.1",
     "coveralls": "^3.1.0",
     "eslint": "^7.17.0",
     "jest": "^26.6.3",
-    "jest-create-mock-instance": "^1.1.0"
+    "jest-create-mock-instance": "^1.1.0",
+    "ts-jest": "^26.5.6",
+    "ts-node": "^10.4.0",
+    "typescript": "^4.5.4"
   },
   "files": [
-    "bin",
-    "!**/fixtures",
+    "dist",
     "index.js",
-    "src",
-    "!*.spec.js"
+    "index.mjs",
+    "!**/fixtures",
+    "!**/*.spec.js"
   ],
   "jest": {
+    "preset": "ts-jest",
     "collectCoverage": true,
     "collectCoverageFrom": [
-      "src/**/*.js"
+      "src/**/*.ts",
+      "!src/index.ts"
     ],
     "coveragePathIgnorePatterns": [
       "/fixtures/",
       "/node_modules/"
     ],
-    "testEnvironment": "node"
+    "testEnvironment": "node",
+    "testPathIgnorePatterns": [
+      "/node_modules/",
+      "/dist"
+    ]
   }
 }