concurrently 9.2.0 → 10.0.0

package/dist/{src → lib}/concurrently.d.ts

@@ -1,10 +1,8 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { Writable } from 'stream';
-import { CloseEvent, Command, CommandIdentifier, CommandInfo, KillProcess, SpawnCommand } from './command';
-import { SuccessCondition } from './completion-listener';
-import { FlowController } from './flow-control/flow-controller';
-import { Logger } from './logger';
+import { Writable } from 'node:stream';
+import { CloseEvent, Command, CommandIdentifier, CommandInfo, KillProcess, SpawnCommand } from './command.js';
+import { SuccessCondition } from './completion-listener.js';
+import { FlowController } from './flow-control/flow-controller.js';
+import { Logger } from './logger.js';
 /**
  * A command that is to be passed into `concurrently()`.
  * If value is a string, then that's the command's command line.
@@ -13,7 +11,7 @@ import { Logger } from './logger';
 export type ConcurrentlyCommandInput = string | ({
     command: string;
 } & Partial<CommandInfo>);
-export type ConcurrentlyResult = {
+export interface ConcurrentlyResult {
     /**
      * All commands created and ran by concurrently.
      */
@@ -26,8 +24,8 @@ export type ConcurrentlyResult = {
      * spawned; commands that didn't spawn are filtered out.
      */
     result: Promise<CloseEvent[]>;
-};
-export type ConcurrentlyOptions = {
+}
+export interface ConcurrentlyOptions {
     logger?: Logger;
     /**
      * Which stream should the commands output be written to.
@@ -38,7 +36,7 @@ export type ConcurrentlyOptions = {
      */
     group?: boolean;
     /**
-     * A comma-separated list of chalk colors or a string for available styles listed below to use on prefixes.
+     * A comma-separated list of Chalk colors or a string for available styles listed below to use on prefixes.
      * If there are more commands than colors, the last color will be repeated.
      *
      * Available modifiers:
@@ -108,7 +106,7 @@ export type ConcurrentlyOptions = {
      * @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.

package/dist/{src → lib}/concurrently.js

@@ -1,26 +1,19 @@
-"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 os_1 = require("os");
-const rxjs_1 = require("rxjs");
-const tree_kill_1 = __importDefault(require("tree-kill"));
-const command_1 = require("./command");
-const expand_arguments_1 = require("./command-parser/expand-arguments");
-const expand_shortcut_1 = require("./command-parser/expand-shortcut");
-const expand_wildcard_1 = require("./command-parser/expand-wildcard");
-const strip_quotes_1 = require("./command-parser/strip-quotes");
-const completion_listener_1 = require("./completion-listener");
-const output_writer_1 = require("./output-writer");
-const prefix_color_selector_1 = require("./prefix-color-selector");
-const spawn_1 = require("./spawn");
+import assert from 'node:assert';
+import os from 'node:os';
+import { takeUntil } from 'rxjs';
+import treeKill from 'tree-kill';
+import { Command, } from './command.js';
+import { ExpandArguments } from './command-parser/expand-arguments.js';
+import { ExpandShortcut } from './command-parser/expand-shortcut.js';
+import { ExpandWildcard } from './command-parser/expand-wildcard.js';
+import { CompletionListener } from './completion-listener.js';
+import { OutputWriter } from './output-writer.js';
+import { PrefixColorSelector } from './prefix-color-selector.js';
+import { createSpawn, getSpawnOpts } from './spawn.js';
+import { castArray } from './utils.js';
 const defaults = {
-    spawn: spawn_1.spawn,
-    kill: tree_kill_1.default,
+    spawn: createSpawn(),
+    kill: treeKill,
     raw: false,
     controllers: [],
     cwd: undefined,
@@ -31,64 +24,59 @@ const defaults = {
  *
  * @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 prefixColorSelector = new prefix_color_selector_1.PrefixColorSelector(options.prefixColors || []);
-    const commandParsers = [
-        new strip_quotes_1.StripQuotes(),
-        new expand_shortcut_1.ExpandShortcut(),
-        new expand_wildcard_1.ExpandWildcard(),
-    ];
+export function concurrently(baseCommands, baseOptions) {
+    assert.ok(Array.isArray(baseCommands), '[concurrently] commands should be an array');
+    assert.notStrictEqual(baseCommands.length, 0, '[concurrently] no commands provided');
+    const options = { ...defaults, ...baseOptions };
+    const prefixColorSelector = new PrefixColorSelector(options.prefixColors || []);
+    const commandParsers = [new ExpandShortcut(), new ExpandWildcard()];
     if (options.additionalArguments) {
-        commandParsers.push(new expand_arguments_1.ExpandArguments(options.additionalArguments));
+        commandParsers.push(new ExpandArguments(options.additionalArguments));
     }
     const hide = (options.hide || []).map(String);
-    let commands = (0, lodash_1.default)(baseCommands)
+    let commands = baseCommands
         .map(mapToCommandInfo)
         .flatMap((command) => parseCommand(command, commandParsers))
         .map((command, index) => {
         const hidden = hide.includes(command.name) || hide.includes(String(index));
-        return new command_1.Command({
+        return new Command({
             index,
             prefixColor: prefixColorSelector.getNextColor(),
             ...command,
-        }, (0, spawn_1.getSpawnOpts)({
+        }, getSpawnOpts({
             ipc: command.ipc,
-            stdio: hidden ? 'hidden' : command.raw ?? options.raw ? 'raw' : 'normal',
+            stdio: hidden ? 'hidden' : (command.raw ?? options.raw) ? 'raw' : 'normal',
             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] : []),
+            onFinishCallbacks: onFinishCallbacks.concat(onFinish ? [onFinish] : []),
         };
     }, { commands, onFinishCallbacks: [] });
     commands = handleResult.commands;
     if (options.logger && options.outputStream) {
-        const outputWriter = new output_writer_1.OutputWriter({
+        const outputWriter = new OutputWriter({
             outputStream: options.outputStream,
             group: !!options.group,
             commands,
         });
         options.logger.output
             // Stop trying to write after there's been an error.
-            .pipe((0, rxjs_1.takeUntil)(outputWriter.error))
+            .pipe(takeUntil(outputWriter.error))
             .subscribe(({ command, text }) => outputWriter.write(command, text));
     }
     const commandsLeft = commands.slice();
     const maxProcesses = Math.max(1, (typeof options.maxProcesses === 'string' && options.maxProcesses.endsWith('%')
-        ? Math.round(((0, os_1.cpus)().length * Number(options.maxProcesses.slice(0, -1))) / 100)
+        ? Math.round((os.cpus().length * Number(options.maxProcesses.slice(0, -1))) / 100)
         : Number(options.maxProcesses)) || commandsLeft.length);
     for (let i = 0; i < maxProcesses; i++) {
         maybeRunMore(commandsLeft, options.abortSignal);
     }
-    const result = new completion_listener_1.CompletionListener({ successCondition: options.successCondition })
+    const result = new CompletionListener({ successCondition: options.successCondition })
         .listen(commands, options.abortSignal)
         .finally(() => Promise.all(handleResult.onFinishCallbacks.map((onFinish) => onFinish())));
     return {
@@ -96,12 +84,11 @@ function concurrently(baseCommands, baseOptions) {
         commands,
     };
 }
-exports.concurrently = concurrently;
 function mapToCommandInfo(command) {
     if (typeof command === 'string') {
         return mapToCommandInfo({ command });
     }
-    assert_1.default.ok(command.command, '[concurrently] command cannot be empty');
+    assert.ok(command.command, '[concurrently] command cannot be empty');
     return {
         command: command.command,
         name: command.name || '',
@@ -121,7 +108,7 @@ function mapToCommandInfo(command) {
     };
 }
 function parseCommand(command, parsers) {
-    return parsers.reduce((commands, parser) => lodash_1.default.flatMap(commands, (command) => parser.parse(command)), lodash_1.default.castArray(command));
+    return parsers.reduce((commands, parser) => commands.flatMap((command) => parser.parse(command)), castArray(command));
 }
 function maybeRunMore(commandsLeft, abortSignal) {
     const command = commandsLeft.shift();

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

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

package/dist/lib/concurrently.spec.js

@@ -0,0 +1,320 @@
+import os from 'node:os';
+import { Writable } from 'node:stream';
+import { beforeEach, expect, it, vi } from 'vitest';
+import { createMockInstance } from './__fixtures__/create-mock-instance.js';
+import { createFakeProcess, FakeCommand } from './__fixtures__/fake-command.js';
+import { concurrently } from './concurrently.js';
+import { Logger } from './logger.js';
+let spawn;
+let kill;
+let onFinishHooks;
+let controllers;
+let processes;
+const create = (commands, options = {}) => concurrently(commands, Object.assign(options, { controllers, spawn, kill }));
+beforeEach(() => {
+    vi.resetAllMocks();
+    processes = [];
+    spawn = vi.fn(() => {
+        const process = createFakeProcess(processes.length);
+        processes.push(process);
+        return process;
+    });
+    kill = vi.fn();
+    onFinishHooks = [vi.fn(), vi.fn()];
+    controllers = [
+        { handle: vi.fn((commands) => ({ commands, onFinish: onFinishHooks[0] })) },
+        { handle: vi.fn((commands) => ({ commands, onFinish: onFinishHooks[1] })) },
+    ];
+});
+it('fails if commands is not an array', () => {
+    const bomb = () => create('foo');
+    expect(bomb).toThrow();
+});
+it('fails if no commands were provided', () => {
+    const bomb = () => create([]);
+    expect(bomb).toThrow();
+});
+it('spawns all commands', () => {
+    create(['echo', 'kill']);
+    expect(spawn).toHaveBeenCalledTimes(2);
+    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({}));
+    expect(spawn).toHaveBeenCalledWith('kill', expect.objectContaining({}));
+});
+it('log output is passed to output stream if logger is specified in options', () => {
+    const logger = new Logger({ hide: [] });
+    const outputStream = createMockInstance(Writable);
+    create(['foo'], { logger, outputStream });
+    logger.log('foo', 'bar');
+    expect(outputStream.write).toHaveBeenCalledTimes(2);
+    expect(outputStream.write).toHaveBeenCalledWith('foo');
+    expect(outputStream.write).toHaveBeenCalledWith('bar');
+});
+it('log output is not passed to output stream after it has errored', () => {
+    const logger = new Logger({ hide: [] });
+    const outputStream = new Writable();
+    vi.spyOn(outputStream, 'write');
+    create(['foo'], { logger, outputStream });
+    outputStream.emit('error', new Error('test'));
+    logger.log('foo', 'bar');
+    expect(outputStream.write).not.toHaveBeenCalled();
+});
+it('spawns commands up to configured limit at once', () => {
+    create(['foo', 'bar', 'baz', 'qux'], { maxProcesses: 2 });
+    expect(spawn).toHaveBeenCalledTimes(2);
+    expect(spawn).toHaveBeenCalledWith('foo', expect.objectContaining({}));
+    expect(spawn).toHaveBeenCalledWith('bar', expect.objectContaining({}));
+    // Test out of order completion picking up new processes in-order
+    processes[1].emit('close', 1, null);
+    expect(spawn).toHaveBeenCalledTimes(3);
+    expect(spawn).toHaveBeenCalledWith('baz', expect.objectContaining({}));
+    processes[0].emit('close', null, 'SIGINT');
+    expect(spawn).toHaveBeenCalledTimes(4);
+    expect(spawn).toHaveBeenCalledWith('qux', expect.objectContaining({}));
+    // Shouldn't attempt to spawn anything else.
+    processes[2].emit('close', 1, null);
+    expect(spawn).toHaveBeenCalledTimes(4);
+});
+it('spawns commands up to percent based limit at once', () => {
+    // Mock architecture with 4 cores
+    const cpusSpy = vi.spyOn(os, 'cpus');
+    cpusSpy.mockReturnValue(Array.from({ length: 4 }).fill({
+        model: 'Intel',
+        speed: 0,
+        times: { user: 0, nice: 0, sys: 0, idle: 0, irq: 0 },
+    }));
+    create(['foo', 'bar', 'baz', 'qux'], { maxProcesses: '50%' });
+    // Max parallel processes should be 2 (50% of 4 cores)
+    expect(spawn).toHaveBeenCalledTimes(2);
+    expect(spawn).toHaveBeenCalledWith('foo', expect.objectContaining({}));
+    expect(spawn).toHaveBeenCalledWith('bar', expect.objectContaining({}));
+    // Close first process and expect third to be spawned
+    processes[0].emit('close', 1, null);
+    expect(spawn).toHaveBeenCalledTimes(3);
+    expect(spawn).toHaveBeenCalledWith('baz', expect.objectContaining({}));
+    // Close second process and expect fourth to be spawned
+    processes[1].emit('close', 1, null);
+    expect(spawn).toHaveBeenCalledTimes(4);
+    expect(spawn).toHaveBeenCalledWith('qux', expect.objectContaining({}));
+});
+it('does not spawn further commands on abort signal aborted', () => {
+    const abortController = new AbortController();
+    create(['foo', 'bar'], { maxProcesses: 1, abortSignal: abortController.signal });
+    expect(spawn).toHaveBeenCalledTimes(1);
+    abortController.abort();
+    processes[0].emit('close', 0, null);
+    expect(spawn).toHaveBeenCalledTimes(1);
+});
+it('preserves quotes in well-formed shell commands in the library API', () => {
+    create(['"/usr/local/bin/mytool" --flag "some value"']);
+    controllers.forEach((controller) => {
+        expect(controller.handle).toHaveBeenCalledWith([
+            expect.objectContaining({
+                command: '"/usr/local/bin/mytool" --flag "some value"',
+                index: 0,
+            }),
+        ]);
+    });
+});
+it('passes commands with multiple quote sets through unchanged in the library API', () => {
+    create(['"/usr/local/bin/mytool" --flag "some value" --other "last arg"']);
+    controllers.forEach((controller) => {
+        expect(controller.handle).toHaveBeenCalledWith([
+            expect.objectContaining({
+                command: '"/usr/local/bin/mytool" --flag "some value" --other "last arg"',
+                index: 0,
+            }),
+        ]);
+    });
+});
+it('runs commands with a name or prefix color', () => {
+    create([{ command: 'echo', prefixColor: 'red', name: 'foo' }, 'kill']);
+    controllers.forEach((controller) => {
+        expect(controller.handle).toHaveBeenCalledWith([
+            expect.objectContaining({ command: 'echo', index: 0, name: 'foo', prefixColor: 'red' }),
+            expect.objectContaining({ command: 'kill', index: 1, name: '', prefixColor: '' }),
+        ]);
+    });
+});
+it('runs commands with a list of colors', () => {
+    create(['echo', 'kill'], {
+        prefixColors: ['red'],
+    });
+    controllers.forEach((controller) => {
+        expect(controller.handle).toHaveBeenCalledWith([
+            expect.objectContaining({ command: 'echo', prefixColor: 'red' }),
+            expect.objectContaining({ command: 'kill', prefixColor: 'red' }),
+        ]);
+    });
+});
+it('passes commands wrapped from a controller to the next one', () => {
+    const fakeCommand = new FakeCommand('banana', 'banana');
+    controllers[0].handle.mockReturnValue({ commands: [fakeCommand] });
+    create(['echo']);
+    expect(controllers[0].handle).toHaveBeenCalledWith([
+        expect.objectContaining({ command: 'echo', index: 0 }),
+    ]);
+    expect(controllers[1].handle).toHaveBeenCalledWith([fakeCommand]);
+    expect(fakeCommand.start).toHaveBeenCalledTimes(1);
+});
+it('merges extra env vars into each command', () => {
+    create([
+        { command: 'echo', env: { foo: 'bar' } },
+        { command: 'echo', env: { foo: 'baz' } },
+        'kill',
+    ]);
+    expect(spawn).toHaveBeenCalledTimes(3);
+    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({
+        env: expect.objectContaining({ foo: 'bar' }),
+    }));
+    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({
+        env: expect.objectContaining({ foo: 'baz' }),
+    }));
+    expect(spawn).toHaveBeenCalledWith('kill', expect.objectContaining({
+        env: expect.not.objectContaining({ foo: expect.anything() }),
+    }));
+});
+it('uses cwd from options for each command', () => {
+    create([
+        { command: 'echo', env: { foo: 'bar' } },
+        { command: 'echo', env: { foo: 'baz' } },
+        'kill',
+    ], {
+        cwd: 'foobar',
+    });
+    expect(spawn).toHaveBeenCalledTimes(3);
+    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({
+        env: expect.objectContaining({ foo: 'bar' }),
+        cwd: 'foobar',
+    }));
+    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({
+        env: expect.objectContaining({ foo: 'baz' }),
+        cwd: 'foobar',
+    }));
+    expect(spawn).toHaveBeenCalledWith('kill', expect.objectContaining({
+        env: expect.not.objectContaining({ foo: expect.anything() }),
+        cwd: 'foobar',
+    }));
+});
+it('uses overridden cwd option for each command if specified', () => {
+    create([
+        { command: 'echo', env: { foo: 'bar' }, cwd: 'baz' },
+        { command: 'echo', env: { foo: 'baz' } },
+    ], {
+        cwd: 'foobar',
+    });
+    expect(spawn).toHaveBeenCalledTimes(2);
+    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({
+        env: expect.objectContaining({ foo: 'bar' }),
+        cwd: 'baz',
+    }));
+    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({
+        env: expect.objectContaining({ foo: 'baz' }),
+        cwd: 'foobar',
+    }));
+});
+it('uses raw from options for each command', () => {
+    create([{ command: 'echo' }, 'kill'], {
+        raw: true,
+    });
+    expect(spawn).toHaveBeenCalledTimes(2);
+    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({
+        stdio: ['inherit', 'inherit', 'inherit'],
+    }));
+    expect(spawn).toHaveBeenCalledWith('kill', expect.objectContaining({
+        stdio: ['inherit', 'inherit', 'inherit'],
+    }));
+});
+it('uses overridden raw option for each command if specified', () => {
+    create([{ command: 'echo', raw: false }, { command: 'echo' }], {
+        raw: true,
+    });
+    expect(spawn).toHaveBeenCalledTimes(2);
+    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({
+        stdio: ['pipe', 'pipe', 'pipe'],
+    }));
+    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({
+        stdio: ['inherit', 'inherit', 'inherit'],
+    }));
+});
+it('uses hide from options for each command', () => {
+    create([{ command: 'echo' }, 'kill'], {
+        hide: [1],
+    });
+    expect(spawn).toHaveBeenCalledTimes(2);
+    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({
+        stdio: ['pipe', 'pipe', 'pipe'],
+    }));
+    expect(spawn).toHaveBeenCalledWith('kill', expect.objectContaining({
+        stdio: ['pipe', 'ignore', 'ignore'],
+    }));
+});
+it('hides output for commands even if raw option is on', () => {
+    create([{ command: 'echo' }, 'kill'], {
+        hide: [1],
+        raw: true,
+    });
+    expect(spawn).toHaveBeenCalledTimes(2);
+    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({
+        stdio: ['inherit', 'inherit', 'inherit'],
+    }));
+    expect(spawn).toHaveBeenCalledWith('kill', expect.objectContaining({
+        stdio: ['pipe', 'ignore', 'ignore'],
+    }));
+});
+it('argument placeholders are properly replaced when additional arguments are passed', () => {
+    create([
+        { command: 'echo {1}' },
+        { command: 'echo {@}' },
+        { command: 'echo {*}' },
+        { command: 'echo \\{@}' },
+    ], {
+        additionalArguments: ['foo', 'bar'],
+    });
+    expect(spawn).toHaveBeenCalledTimes(4);
+    expect(spawn).toHaveBeenCalledWith('echo foo', expect.objectContaining({}));
+    expect(spawn).toHaveBeenCalledWith('echo foo bar', expect.objectContaining({}));
+    expect(spawn).toHaveBeenCalledWith("echo 'foo bar'", expect.objectContaining({}));
+    expect(spawn).toHaveBeenCalledWith('echo {@}', expect.objectContaining({}));
+});
+it('argument placeholders are not replaced when additional arguments are not defined', () => {
+    create([
+        { command: 'echo {1}' },
+        { command: 'echo {@}' },
+        { command: 'echo {*}' },
+        { command: 'echo \\{@}' },
+    ]);
+    expect(spawn).toHaveBeenCalledTimes(4);
+    expect(spawn).toHaveBeenCalledWith('echo {1}', expect.objectContaining({}));
+    expect(spawn).toHaveBeenCalledWith('echo {@}', expect.objectContaining({}));
+    expect(spawn).toHaveBeenCalledWith('echo {*}', expect.objectContaining({}));
+    expect(spawn).toHaveBeenCalledWith('echo {@}', expect.objectContaining({}));
+});
+it('runs onFinish hook after all commands run', async () => {
+    const promise = create(['foo', 'bar'], { maxProcesses: 1 });
+    expect(spawn).toHaveBeenCalledTimes(1);
+    expect(onFinishHooks[0]).not.toHaveBeenCalled();
+    expect(onFinishHooks[1]).not.toHaveBeenCalled();
+    processes[0].emit('close', 0, null);
+    expect(spawn).toHaveBeenCalledTimes(2);
+    expect(onFinishHooks[0]).not.toHaveBeenCalled();
+    expect(onFinishHooks[1]).not.toHaveBeenCalled();
+    processes[1].emit('close', 0, null);
+    await promise.result;
+    expect(onFinishHooks[0]).toHaveBeenCalled();
+    expect(onFinishHooks[1]).toHaveBeenCalled();
+});
+// This test should time out if broken
+it('waits for onFinish hooks to complete before resolving', async () => {
+    onFinishHooks[0].mockResolvedValue(undefined);
+    const { result } = create(['foo', 'bar']);
+    processes[0].emit('close', 0, null);
+    processes[1].emit('close', 0, null);
+    await expect(result).resolves.toBeDefined();
+});
+it('rejects if onFinish hooks reject', async () => {
+    onFinishHooks[0].mockRejectedValue('error');
+    const { result } = create(['foo', 'bar']);
+    processes[0].emit('close', 0, null);
+    processes[1].emit('close', 0, null);
+    await expect(result).rejects.toBe('error');
+});

package/dist/{src → lib}/date-format.d.ts

@@ -1,7 +1,7 @@
-export type FormatterOptions = {
+export interface FormatterOptions {
     locale?: string;
     calendar?: string;
-};
+}
 /**
  * Unicode-compliant date/time formatter.
  *