concurrently 9.2.0 → 10.0.0

package/dist/bin/normalize-cli-command.spec.js

@@ -0,0 +1,36 @@
+import { expect, it } from 'vitest';
+import { normalizeCliCommand } from './normalize-cli-command.js';
+it('strips outer CLI wrapper double quotes', () => {
+    expect(normalizeCliCommand('"echo foo"')).toBe('echo foo');
+});
+it('strips outer CLI wrapper single quotes', () => {
+    expect(normalizeCliCommand("'echo foo'")).toBe('echo foo');
+});
+it('strips quotes around a single wrapped token', () => {
+    expect(normalizeCliCommand('"echo"')).toBe('echo');
+    expect(normalizeCliCommand("'echo'")).toBe('echo');
+});
+it('preserves quotes in well-formed shell commands', () => {
+    expect(normalizeCliCommand('"/usr/local/bin/mytool" --flag "some value"')).toBe('"/usr/local/bin/mytool" --flag "some value"');
+});
+it('preserves well-formed shell commands with multiple quote sets', () => {
+    expect(normalizeCliCommand('"/usr/local/bin/mytool" --flag "some value" --other "last arg"')).toBe('"/usr/local/bin/mytool" --flag "some value" --other "last arg"');
+});
+it('preserves single quotes in well-formed shell commands', () => {
+    expect(normalizeCliCommand("'printf' '%s %s' foo bar")).toBe("'printf' '%s %s' foo bar");
+});
+it('returns unquoted input unchanged', () => {
+    expect(normalizeCliCommand('echo foo')).toBe('echo foo');
+});
+it('returns an empty string unchanged', () => {
+    expect(normalizeCliCommand('')).toBe('');
+});
+it('leaves ambiguous input unchanged', () => {
+    expect(normalizeCliCommand('"echo foo')).toBe('"echo foo');
+});
+it('leaves input with an unclosed single quote unchanged', () => {
+    expect(normalizeCliCommand("echo foo'")).toBe("echo foo'");
+});
+it('leaves input with mismatched quote types unchanged', () => {
+    expect(normalizeCliCommand('"echo foo\'')).toBe('"echo foo\'');
+});

package/dist/bin/read-package-json.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Read the package.json file of `concurrently`
+ */
+export declare function readPackageJson(): Record<string, unknown>;

package/dist/bin/read-package-json.js

@@ -0,0 +1,17 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+/**
+ * Read the package.json file of `concurrently`
+ */
+export function readPackageJson() {
+    let resolver;
+    try {
+        resolver = require.resolve;
+    }
+    catch {
+        resolver = createRequire(import.meta.url).resolve;
+    }
+    const path = resolver('concurrently/package.json');
+    const content = readFileSync(path, 'utf8');
+    return JSON.parse(content);
+}

package/dist/lib/__fixtures__/create-mock-instance.d.ts

@@ -0,0 +1,2 @@
+import { MockedObject } from 'vitest';
+export declare function createMockInstance<T>(constructor: new (...args: any[]) => T): MockedObject<T>;

package/dist/lib/__fixtures__/create-mock-instance.js

@@ -0,0 +1,5 @@
+import { vi } from 'vitest';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function createMockInstance(constructor) {
+    return new (vi.mockObject(constructor))();
+}

package/dist/lib/__fixtures__/fake-command.d.ts

@@ -0,0 +1,6 @@
+import { ChildProcess, CloseEvent, Command, CommandInfo } from '../command.js';
+export declare class FakeCommand extends Command {
+    constructor(name?: string, command?: string, index?: number, info?: Partial<CommandInfo>);
+}
+export declare const createFakeProcess: (pid: number) => ChildProcess;
+export declare const createFakeCloseEvent: (overrides?: Partial<CloseEvent>) => CloseEvent;

package/dist/lib/__fixtures__/fake-command.js

@@ -0,0 +1,37 @@
+import EventEmitter from 'node:events';
+import { PassThrough, Writable } from 'node:stream';
+import { vi } from 'vitest';
+import { Command } from '../command.js';
+import { createMockInstance } from './create-mock-instance.js';
+export class FakeCommand extends Command {
+    constructor(name = 'foo', command = 'echo foo', index = 0, info) {
+        super({
+            index,
+            name,
+            command,
+            ...info,
+        }, {}, vi.fn(), vi.fn());
+        this.stdin = createMockInstance(Writable);
+        this.start = vi.fn();
+        this.kill = vi.fn();
+    }
+}
+export const createFakeProcess = (pid) => Object.assign(new EventEmitter(), {
+    pid,
+    send: vi.fn(),
+    stdin: new PassThrough(),
+    stdout: new PassThrough(),
+    stderr: new PassThrough(),
+});
+export const createFakeCloseEvent = (overrides) => ({
+    command: new FakeCommand(),
+    index: 0,
+    killed: false,
+    exitCode: 0,
+    timings: {
+        startDate: new Date(),
+        endDate: new Date(),
+        durationSeconds: 0,
+    },
+    ...overrides,
+});

package/dist/lib/assert.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Asserts that some condition is true, and if not, prints a warning about it being deprecated.
+ * The message is printed only once.
+ */
+export declare function assertDeprecated(check: boolean, name: string, message: string): void;
+/**
+ * Asserts that some condition is true, and if not, prints a warning about the runtime not being well supported.
+ * The message is printed only once.
+ */
+export declare function assertNotRuntime(check: boolean, name: string, message: string): void;

package/dist/lib/assert.js

@@ -0,0 +1,24 @@
+const deprecations = new Set();
+/**
+ * Asserts that some condition is true, and if not, prints a warning about it being deprecated.
+ * The message is printed only once.
+ */
+export function assertDeprecated(check, name, message) {
+    if (!check && !deprecations.has(name)) {
+        // eslint-disable-next-line no-console
+        console.warn(`[concurrently] ${name} is deprecated. ${message}`);
+        deprecations.add(name);
+    }
+}
+const runtimes = new Set();
+/**
+ * Asserts that some condition is true, and if not, prints a warning about the runtime not being well supported.
+ * The message is printed only once.
+ */
+export function assertNotRuntime(check, name, message) {
+    if (!check && !runtimes.has(name)) {
+        // eslint-disable-next-line no-console
+        console.warn(`[concurrently] Running via ${name} is not well supported. ${message}`);
+        runtimes.add(name);
+    }
+}

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

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

package/dist/lib/assert.spec.js

@@ -0,0 +1,41 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { assertDeprecated, assertNotRuntime } from './assert.js';
+let consoleMock;
+beforeEach(() => {
+    consoleMock = vi.spyOn(console, 'warn').mockImplementation(() => { });
+});
+afterEach(() => {
+    vi.clearAllMocks();
+});
+describe('assertDeprecated()', () => {
+    it('prints warning with name and message when condition is false', () => {
+        assertDeprecated(false, 'example-flag', 'This is an example message.');
+        expect(consoleMock).toHaveBeenLastCalledWith('[concurrently] example-flag is deprecated. This is an example message.');
+    });
+    it('prints same warning only once', () => {
+        assertDeprecated(false, 'example-flag', 'This is an example message.');
+        assertDeprecated(false, 'different-flag', 'This is another message.');
+        expect(consoleMock).toBeCalledTimes(1);
+        expect(consoleMock).toHaveBeenLastCalledWith('[concurrently] different-flag is deprecated. This is another message.');
+    });
+    it('prints nothing if condition is true', () => {
+        assertDeprecated(true, 'example-flag', 'This is an example message.');
+        expect(consoleMock).not.toHaveBeenCalled();
+    });
+});
+describe('assertNotRuntime()', () => {
+    it('prints warning with name and message when condition is false', () => {
+        assertNotRuntime(false, 'example-flag', 'This is an example message.');
+        expect(consoleMock).toHaveBeenLastCalledWith('[concurrently] Running via example-flag is not well supported. This is an example message.');
+    });
+    it('prints same warning only once', () => {
+        assertNotRuntime(false, 'example-flag', 'This is an example message.');
+        assertNotRuntime(false, 'different-flag', 'This is another message.');
+        expect(consoleMock).toBeCalledTimes(1);
+        expect(consoleMock).toHaveBeenLastCalledWith('[concurrently] Running via different-flag is not well supported. This is another message.');
+    });
+    it('prints nothing if condition is true', () => {
+        assertNotRuntime(true, 'example-flag', 'This is an example message.');
+        expect(consoleMock).not.toHaveBeenCalled();
+    });
+});

package/dist/{src → lib}/command-parser/expand-arguments.d.ts

@@ -1,5 +1,5 @@
-import { CommandInfo } from '../command';
-import { CommandParser } from './command-parser';
+import { CommandInfo } from '../command.js';
+import { CommandParser } from './command-parser.js';
 /**
  * Replace placeholders with additional arguments.
  */
@@ -9,10 +9,10 @@ export declare class ExpandArguments implements CommandParser {
     parse(commandInfo: CommandInfo): {
         command: string;
         name: string;
-        env?: Record<string, unknown> | undefined;
-        cwd?: string | undefined;
-        prefixColor?: string | undefined;
-        ipc?: number | undefined;
-        raw?: boolean | undefined;
+        env?: Record<string, unknown>;
+        cwd?: string;
+        prefixColor?: string;
+        ipc?: number;
+        raw?: boolean;
     };
 }

package/dist/lib/command-parser/expand-arguments.js

@@ -0,0 +1,36 @@
+import { quote } from 'shell-quote';
+/**
+ * Replace placeholders with additional arguments.
+ */
+export class ExpandArguments {
+    additionalArguments;
+    constructor(additionalArguments) {
+        this.additionalArguments = additionalArguments;
+    }
+    parse(commandInfo) {
+        const command = commandInfo.command.replace(/\\?\{([@*]|[1-9]\d*)\}/g, (match, placeholderTarget) => {
+            // Don't replace the placeholder if it is escaped by a backslash.
+            if (match.startsWith('\\')) {
+                return match.slice(1);
+            }
+            if (this.additionalArguments.length > 0) {
+                // Replace numeric placeholder if value exists in additional arguments.
+                if (+placeholderTarget <= this.additionalArguments.length) {
+                    return quote([this.additionalArguments[+placeholderTarget - 1]]);
+                }
+                // Replace all arguments placeholder.
+                if (placeholderTarget === '@') {
+                    return quote(this.additionalArguments);
+                }
+                // Replace combined arguments placeholder.
+                if (placeholderTarget === '*') {
+                    return quote([this.additionalArguments.join(' ')]);
+                }
+            }
+            // Replace placeholder with empty string
+            // if value doesn't exist in additional arguments.
+            return '';
+        });
+        return { ...commandInfo, command };
+    }
+}

package/dist/lib/command-parser/expand-arguments.spec.d.ts

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

package/dist/lib/command-parser/expand-arguments.spec.js

@@ -0,0 +1,57 @@
+import { expect, it } from 'vitest';
+import { ExpandArguments } from './expand-arguments.js';
+const createCommandInfo = (command) => ({
+    command,
+    name: '',
+});
+it('returns command as is when no placeholders', () => {
+    const parser = new ExpandArguments(['foo', 'bar']);
+    const commandInfo = createCommandInfo('echo foo');
+    expect(parser.parse(commandInfo)).toEqual({ ...commandInfo, command: 'echo foo' });
+});
+it('single argument placeholder is replaced', () => {
+    const parser = new ExpandArguments(['foo', 'bar']);
+    const commandInfo = createCommandInfo('echo {1}');
+    expect(parser.parse(commandInfo)).toEqual({ ...commandInfo, command: 'echo foo' });
+});
+it('argument placeholder is replaced and quoted properly', () => {
+    const parser = new ExpandArguments(['foo bar']);
+    const commandInfo = createCommandInfo('echo {1}');
+    expect(parser.parse(commandInfo)).toEqual({ ...commandInfo, command: "echo 'foo bar'" });
+});
+it('multiple single argument placeholders are replaced', () => {
+    const parser = new ExpandArguments(['foo', 'bar']);
+    const commandInfo = createCommandInfo('echo {2} {1}');
+    expect(parser.parse(commandInfo)).toEqual({ ...commandInfo, command: 'echo bar foo' });
+});
+it('empty replacement with single placeholder and not enough passthrough arguments', () => {
+    const parser = new ExpandArguments(['foo', 'bar']);
+    const commandInfo = createCommandInfo('echo {3}');
+    expect(parser.parse(commandInfo)).toEqual({ ...commandInfo, command: 'echo ' });
+});
+it('empty replacement with all placeholder and no passthrough arguments', () => {
+    const parser = new ExpandArguments([]);
+    const commandInfo = createCommandInfo('echo {@}');
+    expect(parser.parse(commandInfo)).toEqual({ ...commandInfo, command: 'echo ' });
+});
+it('empty replacement with combined placeholder and no passthrough arguments', () => {
+    const parser = new ExpandArguments([]);
+    const commandInfo = createCommandInfo('echo {*}');
+    expect(parser.parse(commandInfo)).toEqual({ ...commandInfo, command: 'echo ' });
+});
+it('all arguments placeholder is replaced', () => {
+    const parser = new ExpandArguments(['foo', 'bar']);
+    const commandInfo = createCommandInfo('echo {@}');
+    expect(parser.parse(commandInfo)).toEqual({ ...commandInfo, command: 'echo foo bar' });
+});
+it('combined arguments placeholder is replaced', () => {
+    const parser = new ExpandArguments(['foo', 'bar']);
+    const commandInfo = createCommandInfo('echo {*}');
+    expect(parser.parse(commandInfo)).toEqual({ ...commandInfo, command: "echo 'foo bar'" });
+});
+it('escaped argument placeholders are not replaced', () => {
+    const parser = new ExpandArguments(['foo', 'bar']);
+    // Equals to single backslash on command line
+    const commandInfo = createCommandInfo('echo \\{1} \\{@} \\{*}');
+    expect(parser.parse(commandInfo)).toEqual({ ...commandInfo, command: 'echo {1} {@} {*}' });
+});

package/dist/{src → lib}/command-parser/expand-shortcut.d.ts

@@ -1,5 +1,5 @@
-import { CommandInfo } from '../command';
-import { CommandParser } from './command-parser';
+import { CommandInfo } from '../command.js';
+import { CommandParser } from './command-parser.js';
 /**
  * Expands shortcuts according to the following table:
  *

package/dist/{src → lib}/command-parser/expand-shortcut.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExpandShortcut = void 0;
 /**
  * Expands shortcuts according to the following table:
  *
@@ -13,7 +10,7 @@ exports.ExpandShortcut = void 0;
  * | `node:<script>` | `node --run <script>` |
  * | `deno:<script>` | `deno task <script>`  |
  */
-class ExpandShortcut {
+export class ExpandShortcut {
     parse(commandInfo) {
         const [, prefix, script, args] = /^(npm|yarn|pnpm|bun|node|deno):(\S+)(.*)/.exec(commandInfo.command) || [];
         if (!script) {
@@ -36,4 +33,3 @@ class ExpandShortcut {
         };
     }
 }
-exports.ExpandShortcut = ExpandShortcut;

package/dist/lib/command-parser/expand-shortcut.spec.d.ts

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

package/dist/lib/command-parser/expand-shortcut.spec.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { ExpandShortcut } from './expand-shortcut.js';
+const parser = new ExpandShortcut();
+const createCommandInfo = (command, name = '') => ({
+    name,
+    command,
+});
+it('returns same command if no prefix is present', () => {
+    const commandInfo = createCommandInfo('echo foo');
+    expect(parser.parse(commandInfo)).toBe(commandInfo);
+});
+describe.each([
+    ['npm', 'npm run'],
+    ['yarn', 'yarn run'],
+    ['pnpm', 'pnpm run'],
+    ['bun', 'bun run'],
+    ['node', 'node --run'],
+    ['deno', 'deno task'],
+])(`with '%s:' prefix`, (prefix, command) => {
+    it(`expands to "${command} <script> <args>"`, () => {
+        const commandInfo = createCommandInfo(`${prefix}:foo -- bar`, 'echo');
+        expect(parser.parse(commandInfo)).toEqual({
+            ...commandInfo,
+            name: 'echo',
+            command: `${command} foo -- bar`,
+        });
+    });
+    it('sets name to script name if none', () => {
+        const commandInfo = createCommandInfo(`${prefix}:foo -- bar`);
+        expect(parser.parse(commandInfo)).toEqual({
+            ...commandInfo,
+            name: 'foo',
+            command: `${command} foo -- bar`,
+        });
+    });
+});

package/dist/{src → lib}/command-parser/expand-wildcard.d.ts

@@ -1,5 +1,5 @@
-import { CommandInfo } from '../command';
-import { CommandParser } from './command-parser';
+import { CommandInfo } from '../command.js';
+import { CommandParser } from './command-parser.js';
 /**
  * Finds wildcards in 'npm/yarn/pnpm/bun run', 'node --run' and 'deno task'
  * commands and replaces them with all matching scripts in the NodeJS and Deno

package/dist/{src → lib}/command-parser/expand-wildcard.js

@@ -1,12 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExpandWildcard = void 0;
-const fs_1 = __importDefault(require("fs"));
-const lodash_1 = __importDefault(require("lodash"));
-const jsonc_1 = __importDefault(require("../jsonc"));
+import fs from 'node:fs';
+import JSONC from '../jsonc.js';
+import { escapeRegExp } from '../utils.js';
 // Matches a negative filter surrounded by '(!' and ')'.
 const OMISSION = /\(!([^)]+)\)/;
 /**
@@ -14,30 +8,30 @@ const OMISSION = /\(!([^)]+)\)/;
  * commands and replaces them with all matching scripts in the NodeJS and Deno
  * configuration files of the current directory.
  */
-class ExpandWildcard {
+export class ExpandWildcard {
     readDeno;
     readPackage;
     static readDeno() {
         try {
             let json = '{}';
-            if (fs_1.default.existsSync('deno.json')) {
-                json = fs_1.default.readFileSync('deno.json', { encoding: 'utf-8' });
+            if (fs.existsSync('deno.json')) {
+                json = fs.readFileSync('deno.json', { encoding: 'utf-8' });
             }
-            else if (fs_1.default.existsSync('deno.jsonc')) {
-                json = fs_1.default.readFileSync('deno.jsonc', { encoding: 'utf-8' });
+            else if (fs.existsSync('deno.jsonc')) {
+                json = fs.readFileSync('deno.jsonc', { encoding: 'utf-8' });
             }
-            return jsonc_1.default.parse(json);
+            return JSONC.parse(json);
         }
-        catch (e) {
+        catch {
             return {};
         }
     }
     static readPackage() {
         try {
-            const json = fs_1.default.readFileSync('package.json', { encoding: 'utf-8' });
+            const json = fs.readFileSync('package.json', { encoding: 'utf-8' });
             return JSON.parse(json);
         }
-        catch (e) {
+        catch {
             return {};
         }
     }
@@ -70,7 +64,7 @@ class ExpandWildcard {
         // - <npm|yarn|pnpm|bun> run <script> [args]
         // - node --run <script> [args]
         // - deno task <script> [args]
-        const [, command, scriptGlob, args] = /((?:npm|yarn|pnpm|bun) (?:run)|node --run|deno task) (\S+)([^&]*)/.exec(commandInfo.command) || [];
+        const [, command, scriptGlob, args] = /((?:npm|yarn|pnpm|bun) run|node --run|deno task) (\S+)([^&]*)/.exec(commandInfo.command) || [];
         const wildcardPosition = (scriptGlob || '').indexOf('*');
         // If the regex didn't match an npm script, or it has no wildcard,
         // then we have nothing to do here
@@ -79,29 +73,29 @@ class ExpandWildcard {
         }
         const [, omission] = OMISSION.exec(scriptGlob) || [];
         const scriptGlobSansOmission = scriptGlob.replace(OMISSION, '');
-        const preWildcard = lodash_1.default.escapeRegExp(scriptGlobSansOmission.slice(0, wildcardPosition));
-        const postWildcard = lodash_1.default.escapeRegExp(scriptGlobSansOmission.slice(wildcardPosition + 1));
+        const preWildcard = escapeRegExp(scriptGlobSansOmission.slice(0, wildcardPosition));
+        const postWildcard = escapeRegExp(scriptGlobSansOmission.slice(wildcardPosition + 1));
         const wildcardRegex = new RegExp(`^${preWildcard}(.*?)${postWildcard}$`);
         // If 'commandInfo.name' doesn't match 'scriptGlob', this means a custom name
         // has been specified and thus becomes the prefix (as described in the README).
         const prefix = commandInfo.name !== scriptGlob ? commandInfo.name : '';
-        return this.relevantScripts(command)
-            .map((script) => {
-            if (omission && RegExp(omission).test(script)) {
-                return;
+        const commands = [];
+        for (const script of this.relevantScripts(command)) {
+            if (omission && new RegExp(omission).test(script)) {
+                continue;
             }
-            const [, match] = wildcardRegex.exec(script) || [];
+            const result = wildcardRegex.exec(script);
+            const match = result?.[1];
             if (match !== undefined) {
-                return {
+                commands.push({
                     ...commandInfo,
                     command: `${command} ${script}${args}`,
                     // Will use an empty command name if no prefix has been specified and
                     // the wildcard match is empty, e.g. if `npm:watch-*` matches `npm run watch-`.
                     name: prefix + match,
-                };
+                });
             }
-        })
-            .filter((commandInfo) => !!commandInfo);
+        }
+        return commands;
     }
 }
-exports.ExpandWildcard = ExpandWildcard;

package/dist/lib/command-parser/expand-wildcard.spec.d.ts

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