concurrently 9.2.1 → 10.0.0

package/dist/lib/completion-listener.spec.js

@@ -0,0 +1,229 @@
+import { getEventListeners } from 'node:events';
+import { TestScheduler } from 'rxjs/testing';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { createFakeCloseEvent, FakeCommand } from './__fixtures__/fake-command.js';
+import { CompletionListener } from './completion-listener.js';
+let commands;
+let scheduler;
+beforeEach(() => {
+    commands = [
+        new FakeCommand('foo', 'echo', 0),
+        new FakeCommand('bar', 'echo', 1),
+        new FakeCommand('baz', 'echo', 2),
+    ];
+    scheduler = new TestScheduler(() => true);
+});
+const createController = (successCondition) => new CompletionListener({
+    successCondition,
+    scheduler,
+});
+const emitFakeCloseEvent = (command, event) => {
+    const fakeEvent = createFakeCloseEvent({ ...event, command, index: command.index });
+    command.state = 'exited';
+    command.close.next(fakeEvent);
+    return fakeEvent;
+};
+const flushPromises = () => new Promise((resolve) => setTimeout(resolve, 0));
+describe('listen', () => {
+    it('resolves when there are no commands', async () => {
+        const result = createController().listen([]);
+        await expect(result).resolves.toHaveLength(0);
+    });
+    it('completes only when commands emit a close event, returns close event', async () => {
+        const abortCtrl = new AbortController();
+        const result = createController('all').listen(commands, abortCtrl.signal);
+        commands[0].state = 'started';
+        abortCtrl.abort();
+        const event = emitFakeCloseEvent(commands[0]);
+        scheduler.flush();
+        await expect(result).resolves.toHaveLength(1);
+        await expect(result).resolves.toEqual([event]);
+    });
+    it('completes when abort signal is received and command is stopped, returns nothing', async () => {
+        const abortCtrl = new AbortController();
+        // Use success condition = first to test index access when there are no close events
+        const result = createController('first').listen([new FakeCommand()], abortCtrl.signal);
+        abortCtrl.abort();
+        scheduler.flush();
+        await expect(result).resolves.toHaveLength(0);
+    });
+    it('does not leak memory when listening for abort signals', () => {
+        const abortCtrl = new AbortController();
+        createController().listen(Array.from({ length: 10 }, () => new FakeCommand()), abortCtrl.signal);
+        expect(getEventListeners(abortCtrl.signal, 'abort')).toHaveLength(1);
+    });
+    it('check for success once all commands have emitted at least a single close event', async () => {
+        const finallyCallback = vi.fn();
+        const result = createController().listen(commands).finally(finallyCallback);
+        // Emitting multiple close events to mimic calling command `kill/start` APIs.
+        emitFakeCloseEvent(commands[0]);
+        emitFakeCloseEvent(commands[0]);
+        emitFakeCloseEvent(commands[0]);
+        scheduler.flush();
+        // A broken implementation will have called finallyCallback only after flushing promises
+        await flushPromises();
+        expect(finallyCallback).not.toHaveBeenCalled();
+        emitFakeCloseEvent(commands[1]);
+        emitFakeCloseEvent(commands[2]);
+        scheduler.flush();
+        await expect(result).resolves.toEqual(expect.anything());
+        expect(finallyCallback).toHaveBeenCalled();
+    });
+    it('takes last event emitted from each command', async () => {
+        const result = createController().listen(commands);
+        emitFakeCloseEvent(commands[0], { exitCode: 0 });
+        emitFakeCloseEvent(commands[0], { exitCode: 1 });
+        emitFakeCloseEvent(commands[1], { exitCode: 0 });
+        emitFakeCloseEvent(commands[2], { exitCode: 0 });
+        scheduler.flush();
+        await expect(result).rejects.toEqual(expect.anything());
+    });
+    it('waits for manually restarted events to close', async () => {
+        const finallyCallback = vi.fn();
+        const result = createController().listen(commands).finally(finallyCallback);
+        emitFakeCloseEvent(commands[0]);
+        commands[0].state = 'started';
+        emitFakeCloseEvent(commands[1]);
+        emitFakeCloseEvent(commands[2]);
+        scheduler.flush();
+        // A broken implementation will have called finallyCallback only after flushing promises
+        await flushPromises();
+        expect(finallyCallback).not.toHaveBeenCalled();
+        commands[0].state = 'exited';
+        emitFakeCloseEvent(commands[0]);
+        scheduler.flush();
+        await expect(result).resolves.toEqual(expect.anything());
+        expect(finallyCallback).toHaveBeenCalled();
+    });
+});
+describe('detect commands exit conditions', () => {
+    describe('with default success condition set', () => {
+        it('succeeds if all processes exited with code 0', () => {
+            const result = createController().listen(commands);
+            commands[0].close.next(createFakeCloseEvent({ exitCode: 0 }));
+            commands[1].close.next(createFakeCloseEvent({ exitCode: 0 }));
+            commands[2].close.next(createFakeCloseEvent({ exitCode: 0 }));
+            scheduler.flush();
+            return expect(result).resolves.toEqual(expect.anything());
+        });
+        it('fails if one of the processes exited with non-0 code', () => {
+            const result = createController().listen(commands);
+            commands[0].close.next(createFakeCloseEvent({ exitCode: 0 }));
+            commands[1].close.next(createFakeCloseEvent({ exitCode: 1 }));
+            commands[2].close.next(createFakeCloseEvent({ exitCode: 0 }));
+            scheduler.flush();
+            return expect(result).rejects.toEqual(expect.anything());
+        });
+    });
+    describe('with success condition set to first', () => {
+        it('succeeds if first process to exit has code 0', () => {
+            const result = createController('first').listen(commands);
+            commands[1].close.next(createFakeCloseEvent({ exitCode: 0 }));
+            commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
+            commands[2].close.next(createFakeCloseEvent({ exitCode: 1 }));
+            scheduler.flush();
+            return expect(result).resolves.toEqual(expect.anything());
+        });
+        it('fails if first process to exit has non-0 code', () => {
+            const result = createController('first').listen(commands);
+            commands[1].close.next(createFakeCloseEvent({ exitCode: 1 }));
+            commands[0].close.next(createFakeCloseEvent({ exitCode: 0 }));
+            commands[2].close.next(createFakeCloseEvent({ exitCode: 0 }));
+            scheduler.flush();
+            return expect(result).rejects.toEqual(expect.anything());
+        });
+    });
+    describe('with success condition set to last', () => {
+        it('succeeds if last process to exit has code 0', () => {
+            const result = createController('last').listen(commands);
+            commands[1].close.next(createFakeCloseEvent({ exitCode: 1 }));
+            commands[0].close.next(createFakeCloseEvent({ exitCode: 0 }));
+            commands[2].close.next(createFakeCloseEvent({ exitCode: 0 }));
+            scheduler.flush();
+            return expect(result).resolves.toEqual(expect.anything());
+        });
+        it('fails if last process to exit has non-0 code', () => {
+            const result = createController('last').listen(commands);
+            commands[1].close.next(createFakeCloseEvent({ exitCode: 0 }));
+            commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
+            commands[2].close.next(createFakeCloseEvent({ exitCode: 1 }));
+            scheduler.flush();
+            return expect(result).rejects.toEqual(expect.anything());
+        });
+    });
+    describe.each([
+        // Use the middle command for both cases to make it more difficult to make a mess up
+        // in the implementation cause false passes.
+        ['command-bar', 'bar'],
+        ['command-1', 1],
+    ])('with success condition set to %s', (condition, nameOrIndex) => {
+        it(`succeeds if command ${nameOrIndex} exits with code 0`, () => {
+            const result = createController(condition).listen(commands);
+            emitFakeCloseEvent(commands[0], { exitCode: 1 });
+            emitFakeCloseEvent(commands[1], { exitCode: 0 });
+            emitFakeCloseEvent(commands[2], { exitCode: 1 });
+            scheduler.flush();
+            return expect(result).resolves.toEqual(expect.anything());
+        });
+        it(`succeeds if all commands ${nameOrIndex} exit with code 0`, () => {
+            commands = [commands[0], commands[1], commands[1]];
+            const result = createController(condition).listen(commands);
+            emitFakeCloseEvent(commands[0], { exitCode: 1 });
+            emitFakeCloseEvent(commands[1], { exitCode: 0 });
+            emitFakeCloseEvent(commands[2], { exitCode: 0 });
+            scheduler.flush();
+            return expect(result).resolves.toEqual(expect.anything());
+        });
+        it(`fails if command ${nameOrIndex} exits with non-0 code`, () => {
+            const result = createController(condition).listen(commands);
+            emitFakeCloseEvent(commands[0], { exitCode: 0 });
+            emitFakeCloseEvent(commands[1], { exitCode: 1 });
+            emitFakeCloseEvent(commands[2], { exitCode: 0 });
+            scheduler.flush();
+            return expect(result).rejects.toEqual(expect.anything());
+        });
+        it(`succeeds if command ${nameOrIndex} exits with code 0 even when others fail`, () => {
+            const result = createController(condition).listen(commands);
+            emitFakeCloseEvent(commands[0], { exitCode: 1 });
+            emitFakeCloseEvent(commands[1], { exitCode: 0 });
+            emitFakeCloseEvent(commands[2], { exitCode: 1 });
+            scheduler.flush();
+            return expect(result).resolves.toEqual(expect.anything());
+        });
+        it(`fails if command ${nameOrIndex} doesn't exist`, () => {
+            const result = createController(condition).listen([commands[0]]);
+            emitFakeCloseEvent(commands[0], { exitCode: 0 });
+            scheduler.flush();
+            return expect(result).rejects.toEqual(expect.anything());
+        });
+    });
+    describe.each([
+        // Use the middle command for both cases to make it more difficult to make a mess up
+        // in the implementation cause false passes.
+        ['!command-bar', 'bar'],
+        ['!command-1', 1],
+    ])('with success condition set to %s', (condition, nameOrIndex) => {
+        it(`succeeds if all commands but ${nameOrIndex} exit with code 0`, () => {
+            const result = createController(condition).listen(commands);
+            emitFakeCloseEvent(commands[0], { exitCode: 0 });
+            emitFakeCloseEvent(commands[1], { exitCode: 1 });
+            emitFakeCloseEvent(commands[2], { exitCode: 0 });
+            scheduler.flush();
+            return expect(result).resolves.toEqual(expect.anything());
+        });
+        it(`fails if any commands but ${nameOrIndex} exit with non-0 code`, () => {
+            const result = createController(condition).listen(commands);
+            emitFakeCloseEvent(commands[0], { exitCode: 1 });
+            emitFakeCloseEvent(commands[1], { exitCode: 1 });
+            emitFakeCloseEvent(commands[2], { exitCode: 0 });
+            scheduler.flush();
+            return expect(result).rejects.toEqual(expect.anything());
+        });
+        it(`succeeds if command ${nameOrIndex} doesn't exist`, () => {
+            const result = createController(condition).listen([commands[0]]);
+            emitFakeCloseEvent(commands[0], { exitCode: 0 });
+            scheduler.flush();
+            return expect(result).resolves.toEqual(expect.anything());
+        });
+    });
+});

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

@@ -1,8 +1,8 @@
-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.
@@ -11,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.
      */
@@ -24,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.
@@ -36,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:
@@ -106,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 = concurrently;
-const assert_1 = __importDefault(require("assert"));
-const os_1 = __importDefault(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");
-const utils_1 = require("./utils");
+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,18 +24,14 @@ 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');
+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 prefix_color_selector_1.PrefixColorSelector(options.prefixColors || []);
-    const commandParsers = [
-        new strip_quotes_1.StripQuotes(),
-        new expand_shortcut_1.ExpandShortcut(),
-        new expand_wildcard_1.ExpandWildcard(),
-    ];
+    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 = baseCommands
@@ -50,11 +39,11 @@ function concurrently(baseCommands, baseOptions) {
         .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',
             env: command.env,
@@ -70,24 +59,24 @@ function concurrently(baseCommands, baseOptions) {
     }, { 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((os_1.default.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 {
@@ -99,7 +88,7 @@ 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 || '',
@@ -119,7 +108,7 @@ function mapToCommandInfo(command) {
     };
 }
 function parseCommand(command, parsers) {
-    return parsers.reduce((commands, parser) => commands.flatMap((command) => parser.parse(command)), (0, utils_1.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 {};