concurrently 9.2.0 → 10.0.0

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

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

package/dist/lib/logger.spec.js

@@ -0,0 +1,507 @@
+import { subscribeSpyTo } from '@hirez_io/observer-spy';
+import chalk from 'chalk';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { FakeCommand } from './__fixtures__/fake-command.js';
+import { Logger } from './logger.js';
+beforeEach(() => {
+    // Force Chalk to use colors, otherwise tests may pass when they were supposed to be failing.
+    chalk.level = 3;
+});
+const createLogger = (...options) => {
+    const logger = new Logger(...options);
+    vi.spyOn(logger, 'log');
+    const spy = subscribeSpyTo(logger.output);
+    return { logger, spy };
+};
+describe('#log()', () => {
+    it('emits prefix + text in the output stream', () => {
+        const { logger, spy } = createLogger({});
+        logger.log('foo', 'bar');
+        const values = spy.getValues();
+        expect(values).toHaveLength(2);
+        expect(values[0]).toEqual({ command: undefined, text: 'foo' });
+        expect(values[1]).toEqual({ command: undefined, text: 'bar' });
+    });
+    it('emits multiple lines of text with prefix on each', () => {
+        const { logger, spy } = createLogger({});
+        logger.log('foo', 'bar\nbaz\n');
+        const values = spy.getValues();
+        expect(values).toHaveLength(2);
+        expect(values[0]).toEqual({ command: undefined, text: 'foo' });
+        expect(values[1]).toEqual({ command: undefined, text: 'bar\nfoobaz\n' });
+    });
+    it('does not emit prefix if previous call from same command did not finish with a LF', () => {
+        const { logger, spy } = createLogger({});
+        const command = new FakeCommand();
+        logger.log('foo', 'bar', command);
+        logger.log('foo', 'baz', command);
+        expect(spy.getValuesLength()).toBe(3);
+        expect(spy.getLastValue()).toEqual({ command, text: 'baz' });
+    });
+    it('emits LF and prefix if previous call is from different command and did not finish with a LF', () => {
+        const { logger, spy } = createLogger({});
+        const command1 = new FakeCommand();
+        logger.log('foo', 'bar', command1);
+        const command2 = new FakeCommand();
+        logger.log('foo', 'baz', command2);
+        const values = spy.getValues();
+        expect(values).toHaveLength(5);
+        expect(values).toContainEqual({ command: command1, text: '\n' });
+        expect(values).toContainEqual({ command: command2, text: 'foo' });
+        expect(values).toContainEqual({ command: command2, text: 'baz' });
+    });
+    it('does not emit prefix nor handle text if logger is in raw mode', () => {
+        const { logger, spy } = createLogger({ raw: true });
+        logger.log('foo', 'bar\nbaz\n');
+        const values = spy.getValues();
+        expect(values).toHaveLength(1);
+        expect(values[0]).toEqual({ command: undefined, text: 'bar\nbaz\n' });
+    });
+});
+describe('#logGlobalEvent()', () => {
+    it('does nothing if in raw mode', () => {
+        const { logger } = createLogger({ raw: true });
+        logger.logGlobalEvent('foo');
+        expect(logger.log).not.toHaveBeenCalled();
+    });
+    it('logs in gray dim style with arrow prefix', () => {
+        const { logger } = createLogger({});
+        logger.logGlobalEvent('foo');
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('-->')} `, `${chalk.reset('foo')}\n`);
+    });
+});
+describe('#logCommandText()', () => {
+    it('logs with name if no prefixFormat is set', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('bla');
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('[bla]')} `, 'foo', cmd);
+    });
+    it('logs with index if no prefixFormat is set, and command has no name', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 2);
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('[2]')} `, 'foo', cmd);
+    });
+    it('logs with prefixFormat set to pid', () => {
+        const { logger } = createLogger({ prefixFormat: 'pid' });
+        const cmd = new FakeCommand();
+        cmd.pid = 123;
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('[123]')} `, 'foo', cmd);
+    });
+    it('logs with prefixFormat set to name', () => {
+        const { logger } = createLogger({ prefixFormat: 'name' });
+        const cmd = new FakeCommand('bar');
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('[bar]')} `, 'foo', cmd);
+    });
+    it('logs with prefixFormat set to index', () => {
+        const { logger } = createLogger({ prefixFormat: 'index' });
+        const cmd = new FakeCommand(undefined, undefined, 3);
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('[3]')} `, 'foo', cmd);
+    });
+    it('logs with prefixFormat set to time (with timestampFormat)', () => {
+        const { logger } = createLogger({ prefixFormat: 'time', timestampFormat: 'yyyy' });
+        const cmd = new FakeCommand();
+        logger.logCommandText('foo', cmd);
+        const year = new Date().getFullYear();
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset(`[${year}]`)} `, 'foo', cmd);
+    });
+    it('logs with templated prefixFormat', () => {
+        const { logger } = createLogger({ prefixFormat: '{index}-{name}' });
+        const cmd = new FakeCommand('bar');
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('0-bar')} `, 'foo', cmd);
+    });
+    it('does not strip spaces from beginning or end of prefixFormat', () => {
+        const { logger } = createLogger({ prefixFormat: ' {index}-{name} ' });
+        const cmd = new FakeCommand('bar');
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset(' 0-bar ')} `, 'foo', cmd);
+    });
+    it('logs with no prefix', () => {
+        const { logger } = createLogger({ prefixFormat: 'none' });
+        const cmd = new FakeCommand();
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(chalk.reset(''), 'foo', cmd);
+    });
+    it('logs prefix using command line itself', () => {
+        const { logger } = createLogger({ prefixFormat: 'command' });
+        const cmd = new FakeCommand();
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('[echo foo]')} `, 'foo', cmd);
+    });
+    it('logs prefix using command line itself, capped at commandLength bytes', () => {
+        const { logger } = createLogger({ prefixFormat: 'command', commandLength: 6 });
+        const cmd = new FakeCommand();
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('[ec..oo]')} `, 'foo', cmd);
+    });
+    it('logs default prefixes with padding', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('foo');
+        logger.setPrefixLength(5);
+        logger.logCommandText('bar', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('[foo  ]')} `, 'bar', cmd);
+    });
+    it('logs templated prefixes with padding', () => {
+        const { logger } = createLogger({ prefixFormat: '{name}-{index}' });
+        const cmd = new FakeCommand('foo', undefined, 0);
+        logger.setPrefixLength(6);
+        logger.logCommandText('bar', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('foo-0 ')} `, 'bar', cmd);
+    });
+    it('logs prefix using prefixColor from command', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'blue',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.blue('[1]')} `, 'foo', cmd);
+    });
+    it('logs prefix using default color if prefixColor from command is not a valid color', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'fake.bold',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(chalk.reset('[1]') + ' ', 'foo', cmd);
+    });
+    it('logs prefix in gray dim if prefixColor from command does not exist', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'blue.fake',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('[1]')} `, 'foo', cmd);
+    });
+    it('logs prefix using prefixColor from command if prefixColor is a hex value', () => {
+        const { logger } = createLogger({});
+        const prefixColor = '#32bd8a';
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor,
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.hex(prefixColor)('[1]')} `, 'foo', cmd);
+    });
+    it('logs prefix using prefixColor from command if prefixColor is a hex value with modifiers', () => {
+        const { logger } = createLogger({});
+        const prefixColor = '#32bd8a.inverse';
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor,
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.hex(prefixColor).inverse('[1]')} `, 'foo', cmd);
+    });
+    it('logs prefix using prefixColor from command if prefixColor is a bg hex value (short form)', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'bg#32bd8a',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.bgHex('#32bd8a')('[1]')} `, 'foo', cmd);
+    });
+    it('logs prefix using prefixColor from command if prefixColor is a bg hex value with modifiers (short form)', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'bg#32bd8a.bold',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.bgHex('#32bd8a').bold('[1]')} `, 'foo', cmd);
+    });
+    it('handles 3-digit hex codes for bg hex (short form)', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'bg#f00',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.bgHex('#f00')('[1]')} `, 'foo', cmd);
+    });
+    it('logs prefix using prefixColor from command if prefixColor is a bgHex() value (explicit form)', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'bgHex(#ff5500)',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.bgHex('#ff5500')('[1]')} `, 'foo', cmd);
+    });
+    it('logs prefix using prefixColor from command if prefixColor is a bgHex() value with modifiers (explicit form)', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'bgHex(#ff5500).dim',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.bgHex('#ff5500').dim('[1]')} `, 'foo', cmd);
+    });
+    it('handles 3-digit hex codes for bgHex() (explicit form)', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'bgHex(#0f0)',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.bgHex('#0f0')('[1]')} `, 'foo', cmd);
+    });
+    it('falls back to default color for malformed bgHex() syntax', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'bgHex(invalid)',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('[1]')} `, 'foo', cmd);
+    });
+    it('logs prefix with chained fgColor.bgHex().modifier pattern', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'black.bgHex(#533AFD).dim',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.black.bgHex('#533AFD').dim('[1]')} `, 'foo', cmd);
+    });
+    it('logs prefix with chained fgColor.bg#HEXCODE.modifier pattern', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'black.bg#FF0000.bold',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.black.bgHex('#FF0000').bold('[1]')} `, 'foo', cmd);
+    });
+    it('logs prefix with chained #HEXCODE.bgNamed.modifier pattern', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: '#FF0000.bgBlue.dim',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.hex('#FF0000').bgBlue.dim('[1]')} `, 'foo', cmd);
+    });
+    it('logs prefix using rgb() color function', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'rgb(255,136,0).bold',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.rgb(255, 136, 0).bold('[1]')} `, 'foo', cmd);
+    });
+    it('logs prefix using bgRgb() color function', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'black.bgRgb(100,100,255)',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.black.bgRgb(100, 100, 255)('[1]')} `, 'foo', cmd);
+    });
+    it('logs prefix using ansi256() color function', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'ansi256(199)',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.ansi256(199)('[1]')} `, 'foo', cmd);
+    });
+    it('logs prefix using bgAnsi256() color function', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'ansi256(199).bgAnsi256(50)',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.ansi256(199).bgAnsi256(50)('[1]')} `, 'foo', cmd);
+    });
+    it('logs prefix using hex() explicit function', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'hex(#ff5500)',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.hex('#ff5500')('[1]')} `, 'foo', cmd);
+    });
+    it('falls back to default color for malformed hex() syntax', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'hex(invalid)',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('[1]')} `, 'foo', cmd);
+    });
+    it('falls back to default color for unknown function name', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1, {
+            prefixColor: 'unknownFunc(123)',
+        });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('[1]')} `, 'foo', cmd);
+    });
+    it('does nothing if command is hidden by name', () => {
+        const { logger } = createLogger({ hide: ['abc'] });
+        const cmd = new FakeCommand('abc');
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).not.toHaveBeenCalled();
+    });
+    it('does nothing if command is hidden by index', () => {
+        const { logger } = createLogger({ hide: [3] });
+        const cmd = new FakeCommand('', undefined, 3);
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).not.toHaveBeenCalled();
+    });
+});
+describe('#logCommandText() with color markers', () => {
+    it('colors only the text inside {color}...{/color} within a template prefix', () => {
+        const { logger } = createLogger({ prefixFormat: '[{color}{name}{/color}]' });
+        const cmd = new FakeCommand('bar', undefined, 1, { prefixColor: 'blue' });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`[${chalk.blue('bar')}] `, 'foo', cmd);
+    });
+    it('supports multiple {color}...{/color} pairs in one template', () => {
+        const { logger } = createLogger({
+            prefixFormat: '{color}[{/color}{name}{color}]{/color}',
+        });
+        const cmd = new FakeCommand('bar', undefined, 1, { prefixColor: 'blue' });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.blue('[')}bar${chalk.blue(']')} `, 'foo', cmd);
+    });
+    it('auto-closes an unclosed {color} so the tail stays colored', () => {
+        const { logger } = createLogger({ prefixFormat: '[{color}{name}]' });
+        const cmd = new FakeCommand('bar', undefined, 1, { prefixColor: 'blue' });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`[${chalk.blue('bar]')} `, 'foo', cmd);
+    });
+    it('auto-opens a bare {/color} so the head stays colored', () => {
+        const { logger } = createLogger({ prefixFormat: '{name}{/color}]' });
+        const cmd = new FakeCommand('bar', undefined, 1, { prefixColor: 'blue' });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.blue('bar')}] `, 'foo', cmd);
+    });
+    it('templates without markers stay fully colored (backward compat)', () => {
+        const { logger } = createLogger({ prefixFormat: '{name}-{index}' });
+        const cmd = new FakeCommand('bar', undefined, 1, { prefixColor: 'blue' });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.blue('bar-1')} `, 'foo', cmd);
+    });
+    it('pads templated prefix based on visible length, ignoring marker tokens', () => {
+        const { logger } = createLogger({ prefixFormat: '{color}{name}{/color}' });
+        const cmd = new FakeCommand('foo', undefined, 0, { prefixColor: 'blue' });
+        logger.setPrefixLength(6);
+        logger.logCommandText('bar', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.blue('foo')}    `, 'bar', cmd);
+    });
+    it('strips markers and emits no ANSI escapes when colors are globally off', () => {
+        const { logger } = createLogger({ prefixFormat: '[{color}{name}{/color}]' });
+        logger.toggleColors(false);
+        const cmd = new FakeCommand('bar', undefined, 1, { prefixColor: 'blue' });
+        logger.logCommandText('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith('[bar] ', 'foo', cmd);
+    });
+});
+describe('#logCommandEvent()', () => {
+    it('does nothing if in raw mode', () => {
+        const { logger } = createLogger({ raw: true });
+        logger.logCommandEvent('foo', new FakeCommand());
+        expect(logger.log).not.toHaveBeenCalled();
+    });
+    it('does nothing if command is hidden by name', () => {
+        const { logger } = createLogger({ hide: ['abc'] });
+        const cmd = new FakeCommand('abc');
+        logger.logCommandEvent('foo', cmd);
+        expect(logger.log).not.toHaveBeenCalled();
+    });
+    it('does nothing if command is hidden by index', () => {
+        const { logger } = createLogger({ hide: [3] });
+        const cmd = new FakeCommand('', undefined, 3);
+        logger.logCommandEvent('foo', cmd);
+        expect(logger.log).not.toHaveBeenCalled();
+    });
+    it('logs text in gray dim', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1);
+        logger.logCommandEvent('foo', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('[1]')} `, `${chalk.reset('foo')}\n`, cmd);
+    });
+    it('prepends a LF if previous command write did not end with a LF', () => {
+        const { logger } = createLogger({});
+        const cmd = new FakeCommand('', undefined, 1);
+        logger.logCommandText('text', cmd);
+        logger.logCommandEvent('event', cmd);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('[1]')} `, `\n${chalk.reset('event')}\n`, cmd);
+    });
+});
+describe('#logTable()', () => {
+    it('does not log anything in raw mode', () => {
+        const { logger } = createLogger({ raw: true });
+        logger.logTable([{ foo: 1, bar: 2 }]);
+        expect(logger.log).not.toHaveBeenCalled();
+    });
+    it('does not log anything if value is not an array', () => {
+        const { logger } = createLogger({});
+        logger.logTable({});
+        logger.logTable(null);
+        logger.logTable(0);
+        logger.logTable('');
+        expect(logger.log).not.toHaveBeenCalled();
+    });
+    it('does not log anything if array is empty', () => {
+        const { logger } = createLogger({});
+        logger.logTable([]);
+        expect(logger.log).not.toHaveBeenCalled();
+    });
+    it('does not log anything if array items have no properties', () => {
+        const { logger } = createLogger({});
+        logger.logTable([{}]);
+        expect(logger.log).not.toHaveBeenCalled();
+    });
+    it("logs a header for each item's properties", () => {
+        const { logger } = createLogger({});
+        logger.logTable([{ foo: 1, bar: 2 }]);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('-->')} `, `${chalk.reset('│ foo │ bar │')}\n`);
+    });
+    it("logs padded headers according to longest column's value", () => {
+        const { logger } = createLogger({});
+        logger.logTable([{ a: 'foo', b: 'barbaz' }]);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('-->')} `, `${chalk.reset('│ a   │ b      │')}\n`);
+    });
+    it("logs each items's values", () => {
+        const { logger } = createLogger({});
+        logger.logTable([{ foo: 123 }, { foo: 456 }]);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('-->')} `, `${chalk.reset('│ 123 │')}\n`);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('-->')} `, `${chalk.reset('│ 456 │')}\n`);
+    });
+    it("logs each items's values with empty column", () => {
+        const { logger } = createLogger({});
+        logger.logTable([{ foo: 123 }, { foo: null }]);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('-->')} `, `${chalk.reset('│ 123 │')}\n`);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('-->')} `, `${chalk.reset('│     │')}\n`);
+    });
+    it("logs each items's values padded according to longest column's value", () => {
+        const { logger } = createLogger({});
+        logger.logTable([{ foo: 1 }, { foo: 123 }]);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('-->')} `, `${chalk.reset('│ 1   │')}\n`);
+    });
+    it('logs items with different properties in each', () => {
+        const { logger } = createLogger({});
+        logger.logTable([{ foo: 1 }, { bar: 2 }]);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('-->')} `, `${chalk.reset('│ foo │ bar │')}\n`);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('-->')} `, `${chalk.reset('│ 1   │     │')}\n`);
+        expect(logger.log).toHaveBeenCalledWith(`${chalk.reset('-->')} `, `${chalk.reset('│     │ 2   │')}\n`);
+    });
+});
+describe('#toggleColors()', () => {
+    it('uses supported color level when on', () => {
+        const { logger, spy } = createLogger({});
+        logger.toggleColors(true);
+        const command1 = new FakeCommand('foo', 'command', 0, { prefixColor: 'red' });
+        logger.logCommandText('bar', command1);
+        logger.logGlobalEvent('baz');
+        const texts = spy.getValues().map((value) => value.text);
+        expect(texts).toContain(`${chalk.red('[foo]')} `);
+        expect(texts).toContain(`${chalk.reset('-->')} `);
+    });
+    it('uses no colors when off', () => {
+        const { logger, spy } = createLogger({});
+        logger.toggleColors(false);
+        const command1 = new FakeCommand('foo', 'command', 0, { prefixColor: 'red' });
+        logger.logCommandText('bar', command1);
+        logger.logGlobalEvent('baz');
+        const texts = spy.getValues().map((value) => value.text);
+        expect(texts).toContain('[foo] ');
+        expect(texts).toContain('--> ');
+    });
+});

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

@@ -1,5 +1,4 @@
-/// <reference types="node" />
-import EventEmitter from 'events';
+import EventEmitter from 'node:events';
 import { Observable } from 'rxjs';
 /**
  * Creates an observable for a specific event of an `EventEmitter` instance.

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

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromSharedEvent = void 0;
-const rxjs_1 = require("rxjs");
+import { fromEvent, share } from 'rxjs';
 const sharedEvents = new WeakMap();
 /**
  * Creates an observable for a specific event of an `EventEmitter` instance.
  *
  * The underlying event listener is set up only once across the application for that event emitter/name pair.
  */
-function fromSharedEvent(emitter, event) {
+export function fromSharedEvent(emitter, event) {
     let emitterEvents = sharedEvents.get(emitter);
     if (!emitterEvents) {
         emitterEvents = new Map();
@@ -16,9 +13,8 @@ function fromSharedEvent(emitter, event) {
     }
     let observable = emitterEvents.get(event);
     if (!observable) {
-        observable = (0, rxjs_1.fromEvent)(emitter, event).pipe((0, rxjs_1.share)());
+        observable = fromEvent(emitter, event).pipe(share());
         emitterEvents.set(event, observable);
     }
     return observable;
 }
-exports.fromSharedEvent = fromSharedEvent;

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

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

package/dist/lib/observables.spec.js

@@ -0,0 +1,29 @@
+import EventEmitter from 'node:events';
+import { describe, expect, it } from 'vitest';
+import { fromSharedEvent } from './observables.js';
+describe('fromSharedEvent()', () => {
+    it('returns same observable for event emitter/name pair', () => {
+        const emitter = new EventEmitter();
+        const obs1 = fromSharedEvent(emitter, 'foo');
+        const obs2 = fromSharedEvent(emitter, 'foo');
+        expect(obs1).toBe(obs2);
+    });
+    it('returns different observables for different event emitter/name pairs', () => {
+        const emitter = new EventEmitter();
+        const obs1 = fromSharedEvent(emitter, 'foo');
+        const obs2 = fromSharedEvent(emitter, 'bar');
+        expect(obs1).not.toBe(obs2);
+        const emitter2 = new EventEmitter();
+        const obs3 = fromSharedEvent(emitter2, 'foo');
+        const obs4 = fromSharedEvent(emitter2, 'bar');
+        expect(obs1).not.toBe(obs3);
+        expect(obs2).not.toBe(obs4);
+    });
+    it('sets up listener only once per event emitter/name pair', () => {
+        const emitter = new EventEmitter();
+        const observable = fromSharedEvent(emitter, 'foo');
+        observable.subscribe();
+        observable.subscribe();
+        expect(emitter.listenerCount('foo')).toBe(1);
+    });
+});

package/dist/{src → lib}/output-writer.d.ts

@@ -1,7 +1,6 @@
-/// <reference types="node" />
-import * as Rx from 'rxjs';
-import { Writable } from 'stream';
-import { Command } from './command';
+import { Writable } from 'node:stream';
+import Rx from 'rxjs';
+import { Command } from './command.js';
 /**
  * Class responsible for actually writing output onto a writable stream.
  */

package/dist/{src → lib}/output-writer.js

@@ -1,35 +1,9 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (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"));
-const observables_1 = require("./observables");
+import Rx from 'rxjs';
+import { fromSharedEvent } from './observables.js';
 /**
  * Class responsible for actually writing output onto a writable stream.
  */
-class OutputWriter {
+export class OutputWriter {
     outputStream;
     group;
     buffers;
@@ -41,7 +15,7 @@ class OutputWriter {
     constructor({ outputStream, group, commands, }) {
         this.outputStream = outputStream;
         this.ensureWritable();
-        this.error = (0, observables_1.fromSharedEvent)(this.outputStream, 'error');
+        this.error = fromSharedEvent(this.outputStream, 'error');
         this.group = group;
         this.buffers = commands.map(() => []);
         if (this.group) {
@@ -87,4 +61,3 @@ class OutputWriter {
         this.buffers[index] = [];
     }
 }
-exports.OutputWriter = OutputWriter;

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

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