concurrently 10.0.0 → 10.0.1

package/dist/lib/output-writer.spec.js

@@ -1,96 +0,0 @@
-import { Writable } from 'node:stream';
-import { beforeEach, describe, expect, it } from 'vitest';
-import { createMockInstance } from './__fixtures__/create-mock-instance.js';
-import { createFakeCloseEvent, FakeCommand } from './__fixtures__/fake-command.js';
-import { OutputWriter } from './output-writer.js';
-let outputStream;
-let commands;
-function createWriter(overrides) {
-    const options = {
-        outputStream,
-        group: false,
-        commands,
-        ...overrides,
-    };
-    return new OutputWriter(options);
-}
-function closeCommand(command) {
-    command.state = 'exited';
-    command.close.next(createFakeCloseEvent({ command, index: command.index }));
-}
-beforeEach(() => {
-    outputStream = createMockInstance(Writable);
-    commands = [
-        new FakeCommand('', undefined, 0),
-        new FakeCommand('', undefined, 1),
-        new FakeCommand('', undefined, 2),
-    ];
-});
-it('throws if outputStream already is in errored state', () => {
-    Object.defineProperty(outputStream, 'errored', { value: new Error('test') });
-    expect(() => createWriter()).toThrow(TypeError);
-});
-describe('#write()', () => {
-    it('throws if outputStream has errored', () => {
-        const writer = createWriter();
-        Object.defineProperty(outputStream, 'errored', { value: new Error('test') });
-        expect(() => writer.write(commands[0], 'hello')).toThrow(TypeError);
-    });
-    describe('with group=false', () => {
-        it('writes instantly', () => {
-            const writer = createWriter({ group: false });
-            writer.write(commands[2], 'hello');
-            expect(outputStream.write).toHaveBeenCalledExactlyOnceWith('hello');
-        });
-    });
-    describe('with group=true', () => {
-        it('writes for null commands', () => {
-            const writer = createWriter({ group: true });
-            writer.write(undefined, 'hello');
-            expect(outputStream.write).toHaveBeenCalledExactlyOnceWith('hello');
-        });
-        it('does not write instantly for non-active command', () => {
-            const writer = createWriter({ group: true });
-            writer.write(commands[2], 'hello');
-            expect(outputStream.write).toHaveBeenCalledTimes(0);
-            expect(writer.buffers[2]).toEqual(['hello']);
-        });
-        it('write instantly for active command', () => {
-            const writer = createWriter({ group: true });
-            writer.write(commands[0], 'hello');
-            expect(outputStream.write).toHaveBeenCalledExactlyOnceWith('hello');
-        });
-        it('does not wait for write from next command to flush', () => {
-            const writer = createWriter({ group: true });
-            writer.write(commands[1], 'hello');
-            writer.write(commands[1], 'foo bar');
-            expect(outputStream.write).toHaveBeenCalledTimes(0);
-            closeCommand(commands[0]);
-            expect(outputStream.write).toHaveBeenCalledTimes(2);
-            expect(writer.activeCommandIndex).toBe(1);
-            outputStream.write.mockClear();
-            writer.write(commands[1], 'blah');
-            expect(outputStream.write).toHaveBeenCalledTimes(1);
-        });
-        it('does not flush for non-active command', () => {
-            const writer = createWriter({ group: true });
-            writer.write(commands[1], 'hello');
-            writer.write(commands[1], 'foo bar');
-            expect(outputStream.write).toHaveBeenCalledTimes(0);
-            closeCommand(commands[1]);
-            expect(outputStream.write).toHaveBeenCalledTimes(0);
-            closeCommand(commands[0]);
-            expect(outputStream.write).toHaveBeenCalledTimes(2);
-        });
-        it('flushes multiple commands at a time if necessary', () => {
-            const writer = createWriter({ group: true });
-            writer.write(commands[2], 'hello');
-            closeCommand(commands[1]);
-            closeCommand(commands[2]);
-            expect(outputStream.write).toHaveBeenCalledTimes(0);
-            closeCommand(commands[0]);
-            expect(outputStream.write).toHaveBeenCalledExactlyOnceWith('hello');
-            expect(writer.activeCommandIndex).toBe(2);
-        });
-    });
-});

package/dist/lib/prefix-color-selector.spec.d.ts

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

package/dist/lib/prefix-color-selector.spec.js

@@ -1,159 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { PrefixColorSelector } from './prefix-color-selector.js';
-afterEach(() => {
-    vi.restoreAllMocks();
-});
-describe('#getNextColor()', () => {
-    const customTests = {
-        'does not produce a color if prefixColors empty': {
-            customColors: [],
-            expectedColors: ['', '', ''],
-        },
-        'does not produce a color if prefixColors undefined': {
-            expectedColors: ['', '', ''],
-        },
-        'uses user defined prefix colors only, if no auto is used': {
-            customColors: ['red', 'green', 'blue'],
-            expectedColors: [
-                'red',
-                'green',
-                'blue',
-                // Uses last color if last color is not "auto"
-                'blue',
-                'blue',
-                'blue',
-            ],
-        },
-        'trims colors': {
-            customColors: ['  red  ', '  green  ', '  blue  '],
-            expectedColors: ['red', 'green', 'blue'],
-        },
-        'accepts a string value for customColors': {
-            customColors: 'red',
-            expectedColors: ['red', 'red'],
-        },
-        'picks varying colors when user defines an auto color': {
-            acceptableConsoleColors: ['green', 'blue'],
-            customColors: [
-                'red',
-                'green',
-                'auto',
-                'green',
-                'auto',
-                'green',
-                'auto',
-                'blue',
-                'auto',
-                'orange',
-            ],
-            expectedColors: [
-                // Custom colors
-                'red',
-                'green',
-                'blue', // Picks auto color "blue", not repeating consecutive "green" color
-                'green', // Manual
-                'blue', // Auto picks "blue" not to repeat last
-                'green', // Manual
-                'blue', // Auto picks "blue" again not to repeat last
-                'blue', // Manual
-                'green', // Auto picks "green" again not to repeat last
-                'orange',
-                // Uses last color if last color is not "auto"
-                'orange',
-                'orange',
-                'orange',
-            ],
-        },
-        'uses user defined colors then recurring auto colors without repeating consecutive colors': {
-            acceptableConsoleColors: ['green', 'blue'],
-            customColors: ['red', 'green', 'auto'],
-            expectedColors: [
-                // Custom colors
-                'red',
-                'green',
-                // Picks auto colors, not repeating consecutive "green" color
-                'blue',
-                'green',
-                'blue',
-                'green',
-            ],
-        },
-        'can sometimes produce consecutive colors': {
-            acceptableConsoleColors: ['green', 'blue'],
-            customColors: ['blue', 'auto'],
-            expectedColors: [
-                // Custom colors
-                'blue',
-                // Picks auto colors
-                'green',
-                // Does not repeat custom colors for initial auto colors, i.e. does not use "blue" again so soon
-                'green', // Consecutive color picked, however practically there would be a lot of colors that need to be set in a particular order for this to occur
-                'blue',
-                'green',
-                'blue',
-                'green',
-                'blue',
-            ],
-        },
-        'considers the Bright variants of colors equal to the normal colors to avoid similar colors': {
-            acceptableConsoleColors: ['greenBright', 'blueBright', 'green', 'blue', 'magenta'],
-            customColors: ['green', 'blue', 'auto'],
-            expectedColors: [
-                // Custom colors
-                'green',
-                'blue',
-                // Picks auto colors, not repeating green and blue colors and variants initially
-                'magenta',
-                // Picks auto colors
-                'greenBright',
-                'blueBright',
-                'green',
-                'blue',
-                'magenta',
-            ],
-        },
-    };
-    it.each(Object.entries(customTests))('%s', (_, { acceptableConsoleColors, customColors, expectedColors }) => {
-        if (acceptableConsoleColors) {
-            vi.spyOn(PrefixColorSelector, 'ACCEPTABLE_CONSOLE_COLORS', 'get').mockReturnValue(acceptableConsoleColors);
-        }
-        const prefixColorSelector = new PrefixColorSelector(customColors);
-        const prefixColorSelectorValues = expectedColors.map(() => prefixColorSelector.getNextColor());
-        expect(prefixColorSelectorValues).toEqual(expectedColors);
-    });
-    const autoTests = {
-        'does not repeat consecutive colors when last prefixColor is auto': false,
-        'handles when more individual auto prefixColors exist than acceptable console colors': true,
-    };
-    it.each(Object.entries(autoTests))('%s', (_, map) => {
-        // Pick auto colors over 2 sets
-        const expectedColors = [
-            ...PrefixColorSelector.ACCEPTABLE_CONSOLE_COLORS,
-            ...PrefixColorSelector.ACCEPTABLE_CONSOLE_COLORS,
-        ];
-        const prefixColorSelector = new PrefixColorSelector(map ? expectedColors.map(() => 'auto') : ['auto']);
-        let previousColor = '';
-        for (const expectedColor of expectedColors) {
-            const actualSelectedColor = prefixColorSelector.getNextColor();
-            expect(actualSelectedColor).not.toBe(previousColor); // No consecutive colors
-            expect(actualSelectedColor).toBe(expectedColor); // Expected color
-            previousColor = actualSelectedColor;
-        }
-    });
-});
-describe('#ACCEPTABLE_CONSOLE_COLORS', () => {
-    it('has more than 1 auto color defined', () => {
-        // (!) The current implementation is based on the assumption that 'ACCEPTABLE_CONSOLE_COLORS'
-        //     always has more than one entry, which is what we enforce via this test
-        expect(PrefixColorSelector.ACCEPTABLE_CONSOLE_COLORS.length).toBeGreaterThan(1);
-    });
-    it('only includes colors that are visually distinct, semantically neutral, and lightweight', () => {
-        expect(PrefixColorSelector.ACCEPTABLE_CONSOLE_COLORS).toEqual([
-            'cyan',
-            'magenta',
-            'green',
-            'yellow',
-            'blue',
-        ]);
-    });
-});

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

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

package/dist/lib/spawn.spec.js

@@ -1,100 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createSpawn, getSpawnOpts } from './spawn.js';
-import { UnreachableError } from './utils.js';
-const baseProcess = {
-    platform: 'win32',
-    cwd: () => '',
-    env: {},
-};
-describe('createSpawn()', () => {
-    const command = 'echo banana';
-    const makeShellArgs = (kind) => {
-        switch (kind) {
-            case 'cmd':
-                return ['/s', '/c', `"${command}"`];
-            case 'posix':
-                return ['-c', command];
-            case 'powershell':
-                return ['-NoProfile', '-Command', command];
-            default:
-                throw new UnreachableError(kind);
-        }
-    };
-    describe('when shell is not provided', () => {
-        it('uses npm_config_script_shell when set', () => {
-            const fakeSpawn = vi.fn();
-            const spawn = createSpawn(undefined, fakeSpawn, {
-                ...baseProcess,
-                env: { npm_config_script_shell: 'C:\\Git\\bin\\bash.exe' },
-            });
-            spawn(command, {});
-            expect(fakeSpawn).toHaveBeenCalledWith('C:\\Git\\bin\\bash.exe', ['-c', command], {});
-        });
-        it('creates spawn function that uses cmd.exe on Windows', () => {
-            const fakeSpawn = vi.fn();
-            const spawn = createSpawn(undefined, fakeSpawn, { ...baseProcess, platform: 'win32' });
-            spawn(command, {});
-            expect(fakeSpawn).toHaveBeenCalledWith('cmd.exe', ['/s', '/c', `"${command}"`], {
-                windowsVerbatimArguments: true,
-            });
-        });
-        it('creates spawn function that uses /bin/sh on non-Windows platforms', () => {
-            const fakeSpawn = vi.fn();
-            const spawn = createSpawn(undefined, fakeSpawn, { ...baseProcess, platform: 'linux' });
-            spawn(command, {});
-            expect(fakeSpawn).toHaveBeenCalledWith('/bin/sh', ['-c', command], expect.objectContaining({}));
-        });
-    });
-    describe.each([
-        { style: 'cmd', file: 'cmd.exe' },
-        { style: 'posix', file: 'C:\\bash.exe' },
-        { style: 'powershell', file: 'pwsh' },
-        { style: 'posix', file: '/bin/sh' },
-        { style: 'posix', file: '/bin/zsh' },
-    ])('when shell is set to $file', ({ style, file }) => {
-        it(`creates spawn function that uses ${file} as shell with ${style} style arguments`, () => {
-            const fakeSpawn = vi.fn();
-            const spawn = createSpawn(file, fakeSpawn, baseProcess);
-            spawn(command, {});
-            expect(fakeSpawn).toHaveBeenCalledWith(file, makeShellArgs(style), expect.objectContaining({}));
-        });
-    });
-});
-describe('getSpawnOpts()', () => {
-    it('sets detached mode to false for Windows platform', () => {
-        expect(getSpawnOpts({ process: baseProcess }).detached).toBe(false);
-    });
-    it('sets stdio to pipe when stdio mode is normal', () => {
-        expect(getSpawnOpts({ stdio: 'normal' }).stdio).toEqual(['pipe', 'pipe', 'pipe']);
-    });
-    it('sets stdio to inherit when stdio mode is raw', () => {
-        expect(getSpawnOpts({ stdio: 'raw' }).stdio).toEqual(['inherit', 'inherit', 'inherit']);
-    });
-    it('sets stdio to ignore stdout + stderr when stdio mode is hidden', () => {
-        expect(getSpawnOpts({ stdio: 'hidden' }).stdio).toEqual(['pipe', 'ignore', 'ignore']);
-    });
-    it('sets an ipc channel at the specified descriptor index', () => {
-        const opts = getSpawnOpts({ ipc: 3 });
-        expect(opts.stdio?.[3]).toBe('ipc');
-    });
-    it('throws if the ipc channel is <= 2', () => {
-        const fn = () => getSpawnOpts({ ipc: 0 });
-        expect(fn).toThrow();
-    });
-    it('merges FORCE_COLOR into env vars if color supported', () => {
-        const process = { ...baseProcess, env: { foo: 'bar' } };
-        expect(getSpawnOpts({ process, colorSupport: false }).env).toEqual(process.env);
-        expect(getSpawnOpts({ process, colorSupport: { level: 1 } }).env).toEqual({
-            FORCE_COLOR: '1',
-            foo: 'bar',
-        });
-    });
-    it('sets default cwd to process.cwd()', () => {
-        const process = { ...baseProcess, cwd: () => 'process-cwd' };
-        expect(getSpawnOpts({ process }).cwd).toBe('process-cwd');
-    });
-    it('overrides default cwd', () => {
-        const cwd = 'foobar';
-        expect(getSpawnOpts({ cwd }).cwd).toBe(cwd);
-    });
-});

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

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

package/dist/lib/utils.spec.js

@@ -1,58 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { castArray, escapeRegExp, splitOutsideParens } from './utils.js';
-describe('#escapeRegExp()', () => {
-    it('escapes all RegExp chars', () => {
-        // eslint-disable-next-line no-useless-escape
-        const result = escapeRegExp('\*?{}.(?<test>.)|[]');
-        expect(result).toBe('\\*\\?\\{\\}\\.\\(\\?<test>\\.\\)\\|\\[\\]');
-    });
-});
-describe('#castArray()', () => {
-    it('returns empty array for nullish input values', () => {
-        const result1 = castArray();
-        const result2 = castArray(undefined);
-        const result3 = castArray(null);
-        expect(result1).toStrictEqual([]);
-        expect(result2).toStrictEqual([]);
-        expect(result3).toStrictEqual([]);
-    });
-    it('directly returns value if it is already of type array', () => {
-        const value = ['example'];
-        const result = castArray(value);
-        expect(result).toBe(value);
-    });
-    describe('casts primitives to an array', () => {
-        it.each([1, 'example', {}])('%s', (value) => {
-            const result = castArray(value);
-            expect(result).toStrictEqual([value]);
-        });
-    });
-});
-describe('#splitOutsideParens()', () => {
-    it('splits on the given delimiter', () => {
-        expect(splitOutsideParens('red,blue', ',')).toEqual(['red', 'blue']);
-    });
-    it('preserves delimiters inside parentheses', () => {
-        expect(splitOutsideParens('red,rgb(255,0,0),blue', ',')).toEqual([
-            'red',
-            'rgb(255,0,0)',
-            'blue',
-        ]);
-    });
-    it('splits chalk-style dotted color paths, preserving function calls', () => {
-        expect(splitOutsideParens('black.bgHex(#533AFD).dim', '.')).toEqual([
-            'black',
-            'bgHex(#533AFD)',
-            'dim',
-        ]);
-    });
-    it('trims whitespace around each segment', () => {
-        expect(splitOutsideParens('  red ,  blue  ', ',')).toEqual(['red', 'blue']);
-    });
-    it('drops empty segments', () => {
-        expect(splitOutsideParens(',,red,,', ',')).toEqual(['red']);
-    });
-    it('returns an empty array for an empty input', () => {
-        expect(splitOutsideParens('', ',')).toEqual([]);
-    });
-});