concurrently 9.2.0 → 10.0.0

package/dist/lib/flow-control/input-handler.spec.js

@@ -0,0 +1,116 @@
+import { Buffer } from 'node:buffer';
+import { PassThrough } from 'node:stream';
+import { beforeEach, expect, it } from 'vitest';
+import { createMockInstance } from '../__fixtures__/create-mock-instance.js';
+import { FakeCommand } from '../__fixtures__/fake-command.js';
+import { Logger } from '../logger.js';
+import { InputHandler } from './input-handler.js';
+let commands;
+let controller;
+let inputStream;
+let logger;
+beforeEach(() => {
+    commands = [new FakeCommand('foo', 'echo foo', 0), new FakeCommand('bar', 'echo bar', 1)];
+    inputStream = new PassThrough();
+    logger = createMockInstance(Logger);
+    controller = new InputHandler({
+        defaultInputTarget: 0,
+        inputStream,
+        logger,
+    });
+});
+it('returns same commands', () => {
+    expect(controller.handle(commands)).toMatchObject({ commands });
+    controller = new InputHandler({ logger, inputStream });
+    expect(controller.handle(commands)).toMatchObject({ commands });
+});
+it('does nothing if called without input stream', () => {
+    new InputHandler({
+        defaultInputTarget: 0,
+        inputStream: undefined,
+        logger,
+    }).handle(commands);
+    inputStream.write('something');
+    expect(commands[0].stdin?.write).not.toHaveBeenCalled();
+});
+it('forwards input stream to default target ID', () => {
+    controller.handle(commands);
+    inputStream.write('something');
+    expect(commands[0].stdin?.write).toHaveBeenCalledExactlyOnceWith('something');
+    expect(commands[1].stdin?.write).not.toHaveBeenCalled();
+});
+it('forwards input stream to target index specified in input', () => {
+    controller.handle(commands);
+    inputStream.write('1:something');
+    inputStream.write('1:multi\nline\n');
+    expect(commands[0].stdin?.write).not.toHaveBeenCalled();
+    expect(commands[1].stdin?.write).toHaveBeenCalledTimes(2);
+    expect(commands[1].stdin?.write).toHaveBeenCalledWith('something');
+    expect(commands[1].stdin?.write).toHaveBeenCalledWith('multi\nline\n');
+});
+it('forwards input stream to target index specified in input when input contains colon', () => {
+    controller.handle(commands);
+    inputStream.emit('data', Buffer.from('1:some:thing'));
+    inputStream.emit('data', Buffer.from('1: :something'));
+    inputStream.emit('data', Buffer.from('1::something'));
+    expect(commands[0].stdin?.write).not.toHaveBeenCalled();
+    expect(commands[1].stdin?.write).toHaveBeenCalledTimes(3);
+    expect(commands[1].stdin?.write).toHaveBeenCalledWith('some:thing');
+    expect(commands[1].stdin?.write).toHaveBeenCalledWith(' :something');
+    expect(commands[1].stdin?.write).toHaveBeenCalledWith(':something');
+});
+it('does not forward input stream when input contains colon in a different format', () => {
+    controller.handle(commands);
+    inputStream.emit('data', Buffer.from('Ruby0::Const::Syntax'));
+    inputStream.emit('data', Buffer.from('1:Ruby1::Const::Syntax'));
+    inputStream.emit('data', Buffer.from('ruby_symbol_arg :my_symbol'));
+    inputStream.emit('data', Buffer.from('ruby_symbol_arg(:my_symbol)'));
+    inputStream.emit('data', Buffer.from('{ruby_key: :my_val}'));
+    inputStream.emit('data', Buffer.from('{:ruby_key=>:my_val}'));
+    inputStream.emit('data', Buffer.from('js_obj = {key: "my_val"}'));
+    expect(commands[1].stdin?.write).toHaveBeenCalledExactlyOnceWith('Ruby1::Const::Syntax');
+    expect(commands[0].stdin?.write).toHaveBeenCalledTimes(6);
+    expect(commands[0].stdin?.write).toHaveBeenCalledWith('Ruby0::Const::Syntax');
+    expect(commands[0].stdin?.write).toHaveBeenCalledWith('ruby_symbol_arg :my_symbol');
+    expect(commands[0].stdin?.write).toHaveBeenCalledWith('ruby_symbol_arg(:my_symbol)');
+    expect(commands[0].stdin?.write).toHaveBeenCalledWith('{ruby_key: :my_val}');
+    expect(commands[0].stdin?.write).toHaveBeenCalledWith('{:ruby_key=>:my_val}');
+    expect(commands[0].stdin?.write).toHaveBeenCalledWith('js_obj = {key: "my_val"}');
+});
+it('forwards input stream to target name specified in input', () => {
+    controller.handle(commands);
+    inputStream.write('bar:something');
+    expect(commands[0].stdin?.write).not.toHaveBeenCalled();
+    expect(commands[1].stdin?.write).toHaveBeenCalledExactlyOnceWith('something');
+});
+it('logs error if command has no stdin open', () => {
+    commands[0].stdin = undefined;
+    controller.handle(commands);
+    inputStream.write('something');
+    expect(commands[1].stdin?.write).not.toHaveBeenCalled();
+    expect(logger.logGlobalEvent).toHaveBeenCalledWith('Unable to find command "0", or it has no stdin open\n');
+});
+it('fallback to default input stream if command is not found', () => {
+    controller.handle(commands);
+    inputStream.write('foobar:something');
+    expect(commands[0].stdin?.write).toHaveBeenCalledExactlyOnceWith('foobar:something');
+    expect(commands[1].stdin?.write).not.toHaveBeenCalled();
+    expect(logger.logGlobalEvent).not.toHaveBeenCalled();
+});
+it('pauses input stream when finished', () => {
+    expect(inputStream.readableFlowing).toBeNull();
+    const { onFinish } = controller.handle(commands);
+    expect(inputStream.readableFlowing).toBe(true);
+    expect(onFinish).toBeDefined();
+    onFinish?.();
+    expect(inputStream.readableFlowing).toBe(false);
+});
+it('does not pause input stream when pauseInputStreamOnFinish is set to false', () => {
+    controller = new InputHandler({ logger, inputStream, pauseInputStreamOnFinish: false });
+    expect(inputStream.readableFlowing).toBeNull();
+    const { onFinish } = controller.handle(commands);
+    expect(inputStream.readableFlowing).toBe(true);
+    expect(onFinish).toBeDefined();
+    onFinish?.();
+    expect(inputStream.readableFlowing).toBe(true);
+});

package/dist/{src → lib}/flow-control/kill-on-signal.d.ts

@@ -1,8 +1,6 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import EventEmitter from 'events';
-import { Command } from '../command';
-import { FlowController } from './flow-controller';
+import EventEmitter from 'node:events';
+import { Command } from '../command.js';
+import { FlowController } from './flow-controller.js';
 /**
  * Watches the main concurrently process for signals and sends the same signal down to each spawned
  * command.

package/dist/{src → lib}/flow-control/kill-on-signal.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KillOnSignal = void 0;
-const operators_1 = require("rxjs/operators");
+import { map } from 'rxjs/operators';
 const SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP'];
 /**
  * Watches the main concurrently process for signals and sends the same signal down to each spawned
  * command.
  */
-class KillOnSignal {
+export class KillOnSignal {
     process;
     abortController;
     constructor({ process, abortController, }) {
@@ -24,7 +21,7 @@ class KillOnSignal {
         SIGNALS.forEach((signal) => this.process.on(signal, signalListener));
         return {
             commands: commands.map((command) => {
-                const closeStream = command.close.pipe((0, operators_1.map)((exitInfo) => {
+                const closeStream = command.close.pipe(map((exitInfo) => {
                     const exitCode = caughtSignal === 'SIGINT' ? 0 : exitInfo.exitCode;
                     return { ...exitInfo, exitCode };
                 }));
@@ -44,4 +41,3 @@ class KillOnSignal {
         };
     }
 }
-exports.KillOnSignal = KillOnSignal;

package/dist/lib/flow-control/kill-on-signal.spec.d.ts

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

package/dist/lib/flow-control/kill-on-signal.spec.js

@@ -0,0 +1,63 @@
+import { EventEmitter } from 'node:events';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { createFakeCloseEvent, FakeCommand } from '../__fixtures__/fake-command.js';
+import { KillOnSignal } from './kill-on-signal.js';
+let commands;
+let controller;
+let process;
+let abortController;
+beforeEach(() => {
+    process = new EventEmitter();
+    commands = [new FakeCommand(), new FakeCommand()];
+    abortController = new AbortController();
+    controller = new KillOnSignal({ process, abortController });
+});
+it('returns commands that keep non-close streams from original commands', () => {
+    const { commands: newCommands } = controller.handle(commands);
+    newCommands.forEach((newCommand, i) => {
+        expect(newCommand.close).not.toBe(commands[i].close);
+        expect(newCommand.error).toBe(commands[i].error);
+        expect(newCommand.stdout).toBe(commands[i].stdout);
+        expect(newCommand.stderr).toBe(commands[i].stderr);
+    });
+});
+it('returns commands that map SIGINT to exit code 0', () => {
+    const { commands: newCommands } = controller.handle(commands);
+    expect(newCommands).not.toBe(commands);
+    expect(newCommands).toHaveLength(commands.length);
+    const callback = vi.fn();
+    newCommands[0].close.subscribe(callback);
+    process.emit('SIGINT', 'SIGINT');
+    // A fake command's .kill() call won't trigger a close event automatically...
+    commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
+    expect(callback).not.toHaveBeenCalledWith(expect.objectContaining({ exitCode: 'SIGINT' }));
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining({ exitCode: 0 }));
+});
+it('returns commands that keep non-SIGINT exit codes', () => {
+    const { commands: newCommands } = controller.handle(commands);
+    expect(newCommands).not.toBe(commands);
+    expect(newCommands).toHaveLength(commands.length);
+    const callback = vi.fn();
+    newCommands[0].close.subscribe(callback);
+    commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining({ exitCode: 1 }));
+});
+describe.each(['SIGINT', 'SIGTERM', 'SIGHUP'])('on %s', (signal) => {
+    it('kills all commands', () => {
+        controller.handle(commands);
+        process.emit(signal, signal);
+        expect(process.listenerCount(signal)).toBe(1);
+        expect(commands[0].kill).toHaveBeenCalledWith(signal);
+        expect(commands[1].kill).toHaveBeenCalledWith(signal);
+    });
+    it('sends abort signal', () => {
+        controller.handle(commands);
+        process.emit(signal, signal);
+        expect(abortController.signal.aborted).toBe(true);
+    });
+    it('removes event listener on finish', () => {
+        const { onFinish } = controller.handle(commands);
+        onFinish();
+        expect(process.listenerCount(signal)).toBe(0);
+    });
+});

package/dist/{src → lib}/flow-control/kill-others.d.ts

@@ -1,7 +1,6 @@
-/// <reference types="node" />
-import { Command } from '../command';
-import { Logger } from '../logger';
-import { FlowController } from './flow-controller';
+import { Command } from '../command.js';
+import { Logger } from '../logger.js';
+import { FlowController } from './flow-controller.js';
 export type ProcessCloseCondition = 'failure' | 'success';
 /**
  * Sends a SIGTERM signal to all commands when one of the commands exits with a matching condition.

package/dist/{src → lib}/flow-control/kill-others.js

@@ -1,16 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KillOthers = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const operators_1 = require("rxjs/operators");
-const command_1 = require("../command");
+import { filter, map } from 'rxjs/operators';
+import { Command } from '../command.js';
+import { castArray } from '../utils.js';
 /**
  * Sends a SIGTERM signal to all commands when one of the commands exits with a matching condition.
  */
-class KillOthers {
+export class KillOthers {
     logger;
     abortController;
     conditions;
@@ -19,7 +13,7 @@ class KillOthers {
     constructor({ logger, abortController, conditions, killSignal, timeoutMs, }) {
         this.logger = logger;
         this.abortController = abortController;
-        this.conditions = lodash_1.default.castArray(conditions);
+        this.conditions = castArray(conditions);
         this.killSignal = killSignal;
         this.timeoutMs = timeoutMs;
     }
@@ -28,10 +22,10 @@ class KillOthers {
         if (!conditions.length) {
             return { commands };
         }
-        const closeStates = commands.map((command) => command.close.pipe((0, operators_1.map)(({ exitCode }) => exitCode === 0 ? 'success' : 'failure'), (0, operators_1.filter)((state) => conditions.includes(state))));
+        const closeStates = commands.map((command) => command.close.pipe(map(({ exitCode }) => exitCode === 0 ? 'success' : 'failure'), filter((state) => conditions.includes(state))));
         closeStates.forEach((closeState) => closeState.subscribe(() => {
             this.abortController?.abort();
-            const killableCommands = commands.filter((command) => command_1.Command.canKill(command));
+            const killableCommands = commands.filter((command) => Command.canKill(command));
             if (killableCommands.length) {
                 this.logger.logGlobalEvent(`Sending ${this.killSignal || 'SIGTERM'} to other processes..`);
                 killableCommands.forEach((command) => command.kill(this.killSignal));
@@ -46,7 +40,7 @@ class KillOthers {
             return;
         }
         setTimeout(() => {
-            const killableCommands = commands.filter((command) => command_1.Command.canKill(command));
+            const killableCommands = commands.filter((command) => Command.canKill(command));
             if (killableCommands) {
                 this.logger.logGlobalEvent(`Sending SIGKILL to ${killableCommands.length} processes..`);
                 killableCommands.forEach((command) => command.kill('SIGKILL'));
@@ -54,4 +48,3 @@ class KillOthers {
         }, this.timeoutMs);
     }
 }
-exports.KillOthers = KillOthers;

package/dist/lib/flow-control/kill-others.spec.d.ts

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

package/dist/lib/flow-control/kill-others.spec.js

@@ -0,0 +1,98 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { createMockInstance } from '../__fixtures__/create-mock-instance.js';
+import { createFakeCloseEvent, createFakeProcess, FakeCommand, } from '../__fixtures__/fake-command.js';
+import { Logger } from '../logger.js';
+import { KillOthers } from './kill-others.js';
+let commands;
+let logger;
+let abortController;
+beforeEach(() => {
+    commands = [new FakeCommand(), new FakeCommand()];
+    logger = createMockInstance(Logger);
+    abortController = new AbortController();
+});
+const createWithConditions = (conditions, opts) => new KillOthers({
+    logger,
+    abortController,
+    conditions,
+    killSignal: undefined,
+    ...opts,
+});
+const assignProcess = (command) => {
+    const process = createFakeProcess(1);
+    command.pid = process.pid;
+    command.process = process;
+};
+const unassignProcess = (command) => {
+    command.pid = undefined;
+    command.process = undefined;
+};
+it('returns same commands', () => {
+    expect(createWithConditions(['success']).handle(commands)).toMatchObject({ commands });
+    expect(createWithConditions(['failure']).handle(commands)).toMatchObject({ commands });
+});
+it('does not kill others if condition does not match', () => {
+    createWithConditions(['failure']).handle(commands);
+    assignProcess(commands[1]);
+    commands[0].close.next(createFakeCloseEvent({ exitCode: 0 }));
+    expect(logger.logGlobalEvent).not.toHaveBeenCalled();
+    expect(commands[0].kill).not.toHaveBeenCalled();
+    expect(commands[1].kill).not.toHaveBeenCalled();
+});
+describe.each(['success', 'failure'])('on %s', (condition) => {
+    const exitCode = condition === 'success' ? 0 : 1;
+    const inversedCode = exitCode === 1 ? 0 : 1;
+    it('kills other processes', () => {
+        createWithConditions([condition]).handle(commands);
+        assignProcess(commands[1]);
+        commands[0].close.next(createFakeCloseEvent({ exitCode }));
+        expect(logger.logGlobalEvent).toHaveBeenCalledExactlyOnceWith('Sending SIGTERM to other processes..');
+        expect(commands[0].kill).not.toHaveBeenCalled();
+        expect(commands[1].kill).toHaveBeenCalledWith(undefined);
+    });
+    it('kills other processes, with specified signal', () => {
+        createWithConditions([condition], { killSignal: 'SIGKILL' }).handle(commands);
+        assignProcess(commands[1]);
+        commands[0].close.next(createFakeCloseEvent({ exitCode }));
+        expect(logger.logGlobalEvent).toHaveBeenCalledExactlyOnceWith('Sending SIGKILL to other processes..');
+        expect(commands[0].kill).not.toHaveBeenCalled();
+        expect(commands[1].kill).toHaveBeenCalledWith('SIGKILL');
+    });
+    it('sends abort signal on condition match', () => {
+        createWithConditions([condition]).handle(commands);
+        commands[0].close.next(createFakeCloseEvent({ exitCode }));
+        expect(abortController.signal.aborted).toBe(true);
+    });
+    it('does not send abort signal on condition mismatch', () => {
+        createWithConditions([condition]).handle(commands);
+        commands[0].close.next(createFakeCloseEvent({ exitCode: inversedCode }));
+        expect(abortController.signal.aborted).toBe(false);
+    });
+});
+it('does nothing if called without conditions', () => {
+    createWithConditions([]).handle(commands);
+    commands[0].close.next(createFakeCloseEvent({ exitCode: 0 }));
+    expect(logger.logGlobalEvent).not.toHaveBeenCalled();
+    expect(commands[0].kill).not.toHaveBeenCalled();
+    expect(commands[1].kill).not.toHaveBeenCalled();
+});
+it('does not try to kill processes already dead', () => {
+    createWithConditions(['failure']).handle(commands);
+    commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
+    expect(logger.logGlobalEvent).not.toHaveBeenCalled();
+    expect(commands[0].kill).not.toHaveBeenCalled();
+    expect(commands[1].kill).not.toHaveBeenCalled();
+});
+it('force kills misbehaving processes after a timeout', () => {
+    vi.useFakeTimers();
+    commands.push(new FakeCommand());
+    createWithConditions(['failure'], { timeoutMs: 500 }).handle(commands);
+    assignProcess(commands[1]);
+    assignProcess(commands[2]);
+    commands[2].kill = vi.fn(() => unassignProcess(commands[2]));
+    commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
+    vi.advanceTimersByTime(500);
+    expect(commands[1].kill).toHaveBeenCalledTimes(2);
+    expect(commands[1].kill).toHaveBeenCalledWith('SIGKILL');
+    expect(commands[2].kill).toHaveBeenCalledTimes(1);
+});

package/dist/{src → lib}/flow-control/log-error.d.ts

@@ -1,6 +1,6 @@
-import { Command } from '../command';
-import { Logger } from '../logger';
-import { FlowController } from './flow-controller';
+import { Command } from '../command.js';
+import { Logger } from '../logger.js';
+import { FlowController } from './flow-controller.js';
 /**
  * Logs when commands failed executing, e.g. due to the executable not existing in the system.
  */

package/dist/{src → lib}/flow-control/log-error.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogError = void 0;
 /**
  * Logs when commands failed executing, e.g. due to the executable not existing in the system.
  */
-class LogError {
+export class LogError {
     logger;
     constructor({ logger }) {
         this.logger = logger;
@@ -18,4 +15,3 @@ class LogError {
         return { commands };
     }
 }
-exports.LogError = LogError;

package/dist/lib/flow-control/log-error.spec.d.ts

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

package/dist/lib/flow-control/log-error.spec.js

@@ -0,0 +1,33 @@
+import { beforeEach, expect, it } from 'vitest';
+import { createMockInstance } from '../__fixtures__/create-mock-instance.js';
+import { FakeCommand } from '../__fixtures__/fake-command.js';
+import { Logger } from '../logger.js';
+import { LogError } from './log-error.js';
+let controller;
+let logger;
+let commands;
+beforeEach(() => {
+    commands = [new FakeCommand(), new FakeCommand(), new FakeCommand()];
+    logger = createMockInstance(Logger);
+    controller = new LogError({ logger });
+});
+it('returns same commands', () => {
+    expect(controller.handle(commands)).toMatchObject({ commands });
+});
+it('logs the error event of each command', () => {
+    controller.handle(commands);
+    commands[0].error.next('error from command 0');
+    const error1 = new Error('test');
+    commands[1].error.next(error1);
+    // Testing Error without stack
+    const error2 = new Error('test');
+    error2.stack = '';
+    commands[2].error.next(error2);
+    expect(logger.logCommandEvent).toHaveBeenCalledTimes(6);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(`Error occurred when executing command: ${commands[0].command}`, commands[0]);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith('error from command 0', commands[0]);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(`Error occurred when executing command: ${commands[1].command}`, commands[1]);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(error1.stack, commands[1]);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(`Error occurred when executing command: ${commands[2].command}`, commands[2]);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(String(error2), commands[2]);
+});

package/dist/{src → lib}/flow-control/log-exit.d.ts

@@ -1,6 +1,6 @@
-import { Command } from '../command';
-import { Logger } from '../logger';
-import { FlowController } from './flow-controller';
+import { Command } from '../command.js';
+import { Logger } from '../logger.js';
+import { FlowController } from './flow-controller.js';
 /**
  * Logs the exit code/signal of commands.
  */

package/dist/{src → lib}/flow-control/log-exit.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogExit = void 0;
 /**
  * Logs the exit code/signal of commands.
  */
-class LogExit {
+export class LogExit {
     logger;
     constructor({ logger }) {
         this.logger = logger;
@@ -16,4 +13,3 @@ class LogExit {
         return { commands };
     }
 }
-exports.LogExit = LogExit;

package/dist/lib/flow-control/log-exit.spec.d.ts

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

package/dist/lib/flow-control/log-exit.spec.js

@@ -0,0 +1,24 @@
+import { beforeEach, expect, it } from 'vitest';
+import { createMockInstance } from '../__fixtures__/create-mock-instance.js';
+import { createFakeCloseEvent, FakeCommand } from '../__fixtures__/fake-command.js';
+import { Logger } from '../logger.js';
+import { LogExit } from './log-exit.js';
+let controller;
+let logger;
+let commands;
+beforeEach(() => {
+    commands = [new FakeCommand(), new FakeCommand()];
+    logger = createMockInstance(Logger);
+    controller = new LogExit({ logger });
+});
+it('returns same commands', () => {
+    expect(controller.handle(commands)).toMatchObject({ commands });
+});
+it('logs the close event of each command', () => {
+    controller.handle(commands);
+    commands[0].close.next(createFakeCloseEvent({ exitCode: 0 }));
+    commands[1].close.next(createFakeCloseEvent({ exitCode: 'SIGTERM' }));
+    expect(logger.logCommandEvent).toHaveBeenCalledTimes(2);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(`${commands[0].command} exited with code 0`, commands[0]);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(`${commands[1].command} exited with code SIGTERM`, commands[1]);
+});

package/dist/{src → lib}/flow-control/log-output.d.ts

@@ -1,6 +1,6 @@
-import { Command } from '../command';
-import { Logger } from '../logger';
-import { FlowController } from './flow-controller';
+import { Command } from '../command.js';
+import { Logger } from '../logger.js';
+import { FlowController } from './flow-controller.js';
 /**
  * Logs the stdout and stderr output of commands.
  */

package/dist/{src → lib}/flow-control/log-output.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogOutput = void 0;
 /**
  * Logs the stdout and stderr output of commands.
  */
-class LogOutput {
+export class LogOutput {
     logger;
     constructor({ logger }) {
         this.logger = logger;
@@ -17,4 +14,3 @@ class LogOutput {
         return { commands };
     }
 }
-exports.LogOutput = LogOutput;

package/dist/lib/flow-control/log-output.spec.d.ts

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

package/dist/lib/flow-control/log-output.spec.js

@@ -0,0 +1,33 @@
+import { Buffer } from 'node:buffer';
+import { beforeEach, expect, it } from 'vitest';
+import { createMockInstance } from '../__fixtures__/create-mock-instance.js';
+import { FakeCommand } from '../__fixtures__/fake-command.js';
+import { Logger } from '../logger.js';
+import { LogOutput } from './log-output.js';
+let controller;
+let logger;
+let commands;
+beforeEach(() => {
+    commands = [new FakeCommand(), new FakeCommand()];
+    logger = createMockInstance(Logger);
+    controller = new LogOutput({ logger });
+});
+it('returns same commands', () => {
+    expect(controller.handle(commands)).toMatchObject({ commands });
+});
+it('logs the stdout of each command', () => {
+    controller.handle(commands);
+    commands[0].stdout.next(Buffer.from('foo'));
+    commands[1].stdout.next(Buffer.from('bar'));
+    expect(logger.logCommandText).toHaveBeenCalledTimes(2);
+    expect(logger.logCommandText).toHaveBeenCalledWith('foo', commands[0]);
+    expect(logger.logCommandText).toHaveBeenCalledWith('bar', commands[1]);
+});
+it('logs the stderr of each command', () => {
+    controller.handle(commands);
+    commands[0].stderr.next(Buffer.from('foo'));
+    commands[1].stderr.next(Buffer.from('bar'));
+    expect(logger.logCommandText).toHaveBeenCalledTimes(2);
+    expect(logger.logCommandText).toHaveBeenCalledWith('foo', commands[0]);
+    expect(logger.logCommandText).toHaveBeenCalledWith('bar', commands[1]);
+});

package/dist/{src → lib}/flow-control/log-timings.d.ts

@@ -1,6 +1,6 @@
-import { CloseEvent, Command } from '../command';
-import { Logger } from '../logger';
-import { FlowController } from './flow-controller';
+import { CloseEvent, Command } from '../command.js';
+import { Logger } from '../logger.js';
+import { FlowController } from './flow-controller.js';
 type TimingInfo = {
     name: string;
     duration: string;