concurrently 9.2.1 → 10.0.0

package/dist/lib/concurrently.spec.js

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

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

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

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

@@ -1,76 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DateFormatter = void 0;
-/**
- * Unicode-compliant date/time formatter.
- *
- * @see https://unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns
- */
-class DateFormatter {
-    options;
-    static tokenRegex = /[A-Z]/i;
-    parts = [];
-    constructor(pattern, options = {}) {
-        this.options = options;
-        let i = 0;
-        while (i < pattern.length) {
-            const char = pattern[i];
-            const { fn, length } = char === "'"
-                ? this.compileLiteral(pattern, i)
-                : DateFormatter.tokenRegex.test(char)
-                    ? this.compileToken(pattern, i)
-                    : this.compileOther(pattern, i);
-            this.parts.push(fn);
-            i += length;
-        }
-    }
-    compileLiteral(pattern, offset) {
-        let length = 1;
-        let value = '';
-        for (; length < pattern.length; length++) {
-            const i = offset + length;
-            const char = pattern[i];
-            if (char === "'") {
-                const nextChar = pattern[i + 1];
-                length++;
-                // if the next character is another single quote, it's been escaped.
-                // if not, then the literal has been closed
-                if (nextChar !== "'") {
-                    break;
-                }
-            }
-            value += char;
-        }
-        return { fn: () => value || "'", length };
-    }
-    compileOther(pattern, offset) {
-        let value = '';
-        while (!DateFormatter.tokenRegex.test(pattern[offset]) && pattern[offset] !== "'") {
-            value += pattern[offset++];
-        }
-        return { fn: () => value, length: value.length };
-    }
-    compileToken(pattern, offset) {
-        const type = pattern[offset];
-        const token = tokens.get(type);
-        if (!token) {
-            throw new SyntaxError(`Formatting token "${type}" is invalid`);
-        }
-        let length = 0;
-        while (pattern[offset + length] === type) {
-            length++;
-        }
-        const tokenFn = token[length - 1];
-        if (!tokenFn) {
-            throw new RangeError(`Formatting token "${type.repeat(length)}" is unsupported`);
-        }
-        return { fn: tokenFn, length };
-    }
-    format(date) {
-        return this.parts.reduce((output, part) => output + String(part(date, this.options)), '');
-    }
-}
-exports.DateFormatter = DateFormatter;
 /**
  * A map of token to its implementations by length.
  * If an index is undefined, then that token length is unsupported.
@@ -241,6 +168,99 @@ function getLocale(options) {
     }
     return locale;
 }
+/**
+ * Unicode-compliant date/time formatter.
+ *
+ * @see https://unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns
+ */
+export class DateFormatter {
+    options;
+    static tokenRegex = /[A-Z]/i;
+    parts = [];
+    constructor(pattern, options = {}) {
+        this.options = options;
+        let i = 0;
+        while (i < pattern.length) {
+            const char = pattern[i];
+            const { fn, length } = char === "'"
+                ? this.compileLiteral(pattern, i)
+                : DateFormatter.tokenRegex.test(char)
+                    ? this.compileToken(pattern, i)
+                    : this.compileOther(pattern, i);
+            this.parts.push(fn);
+            i += length;
+        }
+    }
+    compileLiteral(pattern, offset) {
+        let length = 1;
+        let value = '';
+        for (; length < pattern.length; length++) {
+            const i = offset + length;
+            const char = pattern[i];
+            if (char === "'") {
+                const nextChar = pattern[i + 1];
+                length++;
+                // if the next character is another single quote, it's been escaped.
+                // if not, then the literal has been closed
+                if (nextChar !== "'") {
+                    break;
+                }
+            }
+            value += char;
+        }
+        return { fn: () => value || "'", length };
+    }
+    compileOther(pattern, offset) {
+        let value = '';
+        while (!DateFormatter.tokenRegex.test(pattern[offset]) && pattern[offset] !== "'") {
+            value += pattern[offset++];
+        }
+        return { fn: () => value, length: value.length };
+    }
+    compileToken(pattern, offset) {
+        const type = pattern[offset];
+        const token = tokens.get(type);
+        if (!token) {
+            throw new SyntaxError(`Formatting token "${type}" is invalid`);
+        }
+        let length = 0;
+        while (pattern[offset + length] === type) {
+            length++;
+        }
+        const tokenFn = token[length - 1];
+        if (!tokenFn) {
+            throw new RangeError(`Formatting token "${type.repeat(length)}" is unsupported`);
+        }
+        return { fn: tokenFn, length };
+    }
+    format(date) {
+        return this.parts.reduce((output, part) => output + String(part(date, this.options)), '');
+    }
+}
+/**
+ * See https://github.com/moment/luxon/issues/1693
+ *
+ * @todo Replace once there's a suitable alternative implementation
+ */
+const fallbackWeekInfo = {
+    minimalDays: 4,
+};
+const weekInfoCache = new Map();
+function getWeekInfo(locale) {
+    let data = weekInfoCache.get(locale.baseName);
+    if (!data) {
+        // The specs now envisage a method for this,
+        // see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/getWeekInfo
+        data = locale.getWeekInfo?.() ?? locale.weekInfo;
+        // The specs have dropped minimalDays,
+        // see https://github.com/tc39/proposal-intl-locale-info/issues/86
+        if (!data.minimalDays) {
+            data = { ...fallbackWeekInfo, ...data };
+        }
+        weekInfoCache.set(locale.baseName, data);
+    }
+    return data;
+}
 /**
  * Creates a token formatting function that returns the value of the chosen part type,
  * using the current locale's settings.
@@ -269,7 +289,8 @@ function makeTokenFn(options, type, fallback) {
 }
 function startOfWeek(date, options) {
     const locale = getLocale(options);
-    const firstDay = locale.weekInfo.firstDay === 7 ? 0 : locale.weekInfo.firstDay;
+    const weekInfo = getWeekInfo(locale);
+    const firstDay = weekInfo.firstDay === 7 ? 0 : weekInfo.firstDay;
     const day = date.getDay();
     const diff = (day < firstDay ? 7 : 0) + day - firstDay;
     date.setDate(date.getDate() - diff);
@@ -278,7 +299,7 @@ function startOfWeek(date, options) {
 }
 function getWeekYear(date, options) {
     const locale = getLocale(options);
-    const minimalDays = locale.weekInfo.minimalDays;
+    const minimalDays = getWeekInfo(locale).minimalDays;
     const year = date.getFullYear();
     const thisYear = startOfWeek(new Date(year, 0, minimalDays), options);
     const nextYear = startOfWeek(new Date(year + 1, 0, minimalDays), options);
@@ -296,7 +317,7 @@ function getWeek(date, options) {
     const locale = getLocale(options);
     const weekMs = 7 * 24 * 3600 * 1000;
     const temp = startOfWeek(new Date(date), options);
-    const thisYear = new Date(getWeekYear(date, options), 0, locale.weekInfo.minimalDays);
+    const thisYear = new Date(getWeekYear(date, options), 0, getWeekInfo(locale).minimalDays);
     startOfWeek(thisYear, options);
     const diff = temp.getTime() - thisYear.getTime();
     return Math.round(diff / weekMs) + 1;

package/dist/lib/date-format.spec.d.ts

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