concurrently 9.2.0 → 10.0.0

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

@@ -0,0 +1,288 @@
+import fs from 'node:fs';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ExpandWildcard } from './expand-wildcard.js';
+let parser;
+let readPackage;
+let readDeno;
+const createCommandInfo = (command) => ({
+    command,
+    name: '',
+});
+beforeEach(() => {
+    readDeno = vi.fn();
+    readPackage = vi.fn();
+    parser = new ExpandWildcard(readDeno, readPackage);
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+describe('#readDeno()', () => {
+    it('can read deno.json', () => {
+        const expectedDeno = {
+            name: 'deno',
+            version: '1.14.0',
+        };
+        vi.spyOn(fs, 'existsSync').mockImplementation((path) => {
+            return path === 'deno.json';
+        });
+        vi.spyOn(fs, 'readFileSync').mockImplementation((path) => {
+            if (path === 'deno.json') {
+                return JSON.stringify(expectedDeno);
+            }
+            return '';
+        });
+        const actualReadDeno = ExpandWildcard.readDeno();
+        expect(actualReadDeno).toEqual(expectedDeno);
+    });
+    it('can read deno.jsonc', () => {
+        const expectedDeno = {
+            name: 'deno',
+            version: '1.14.0',
+        };
+        vi.spyOn(fs, 'existsSync').mockImplementation((path) => {
+            return path === 'deno.jsonc';
+        });
+        vi.spyOn(fs, 'readFileSync').mockImplementation((path) => {
+            if (path === 'deno.jsonc') {
+                return `/* comment */\n${JSON.stringify(expectedDeno)}`;
+            }
+            return '';
+        });
+        const actualReadDeno = ExpandWildcard.readDeno();
+        expect(actualReadDeno).toEqual(expectedDeno);
+    });
+    it('prefers deno.json over deno.jsonc', () => {
+        const expectedDeno = {
+            name: 'deno',
+            version: '1.14.0',
+        };
+        vi.spyOn(fs, 'existsSync').mockImplementation((path) => {
+            return path === 'deno.json' || path === 'deno.jsonc';
+        });
+        vi.spyOn(fs, 'readFileSync').mockImplementation((path) => {
+            if (path === 'deno.json') {
+                return JSON.stringify(expectedDeno);
+            }
+            return '';
+        });
+        const actualReadDeno = ExpandWildcard.readDeno();
+        expect(actualReadDeno).toEqual(expectedDeno);
+    });
+    it('can handle errors reading deno', () => {
+        vi.spyOn(fs, 'existsSync').mockReturnValue(true);
+        vi.spyOn(fs, 'readFileSync').mockImplementation(() => {
+            throw new Error('Error reading deno');
+        });
+        expect(() => ExpandWildcard.readDeno()).not.toThrow();
+        expect(ExpandWildcard.readDeno()).toEqual({});
+    });
+});
+describe('#readPackage()', () => {
+    it('can read package', () => {
+        const expectedPackage = {
+            name: 'concurrently',
+            version: '6.4.0',
+        };
+        vi.spyOn(fs, 'readFileSync').mockImplementation((path) => {
+            if (path === 'package.json') {
+                return JSON.stringify(expectedPackage);
+            }
+            return '';
+        });
+        const actualReadPackage = ExpandWildcard.readPackage();
+        expect(actualReadPackage).toEqual(expectedPackage);
+    });
+    it('can handle errors reading package', () => {
+        vi.spyOn(fs, 'readFileSync').mockImplementation(() => {
+            throw new Error('Error reading package');
+        });
+        expect(() => ExpandWildcard.readPackage()).not.toThrow();
+        expect(ExpandWildcard.readPackage()).toEqual({});
+    });
+});
+it('returns same command if not an npm run command', () => {
+    const commandInfo = createCommandInfo('npm test');
+    expect(readDeno).not.toHaveBeenCalled();
+    expect(readPackage).not.toHaveBeenCalled();
+    expect(parser.parse(commandInfo)).toBe(commandInfo);
+});
+it('returns same command if not a deno task command', () => {
+    const commandInfo = createCommandInfo('deno run');
+    expect(readDeno).not.toHaveBeenCalled();
+    expect(readPackage).not.toHaveBeenCalled();
+    expect(parser.parse(commandInfo)).toBe(commandInfo);
+});
+it('returns same command if no wildcard present', () => {
+    const commandInfo = createCommandInfo('npm run foo bar');
+    expect(readPackage).not.toHaveBeenCalled();
+    expect(parser.parse(commandInfo)).toBe(commandInfo);
+});
+it('expands to nothing if no scripts exist in package.json', () => {
+    readPackage.mockReturnValue({});
+    expect(parser.parse(createCommandInfo('npm run foo-*-baz qux'))).toEqual([]);
+});
+it('expands to nothing if no tasks exist in Deno config and no scripts exist in NodeJS config', () => {
+    readDeno.mockReturnValue({});
+    readPackage.mockReturnValue({});
+    expect(parser.parse(createCommandInfo('deno task foo-*-baz qux'))).toEqual([]);
+});
+describe.each(['npm run', 'yarn run', 'pnpm run', 'bun run', 'node --run'])(`with a '%s' prefix`, (command) => {
+    it('expands to all scripts matching pattern', () => {
+        readPackage.mockReturnValue({
+            scripts: {
+                'foo-bar-baz': '',
+                'foo--baz': '',
+            },
+        });
+        expect(parser.parse(createCommandInfo(`${command} foo-*-baz qux`))).toEqual([
+            { name: 'bar', command: `${command} foo-bar-baz qux` },
+            { name: '', command: `${command} foo--baz qux` },
+        ]);
+    });
+    it('uses wildcard match of script as command name', () => {
+        readPackage.mockReturnValue({
+            scripts: {
+                'watch-js': '',
+                'watch-css': '',
+            },
+        });
+        expect(parser.parse({
+            name: 'watch-*',
+            command: `${command} watch-*`,
+        })).toEqual([
+            { name: 'js', command: `${command} watch-js` },
+            { name: 'css', command: `${command} watch-css` },
+        ]);
+    });
+    it('uses existing command name as prefix to the wildcard match', () => {
+        readPackage.mockReturnValue({
+            scripts: {
+                'watch-js': '',
+                'watch-css': '',
+            },
+        });
+        expect(parser.parse({
+            name: 'w:',
+            command: `${command} watch-*`,
+        })).toEqual([
+            { name: 'w:js', command: `${command} watch-js` },
+            { name: 'w:css', command: `${command} watch-css` },
+        ]);
+    });
+    it('allows negation', () => {
+        readPackage.mockReturnValue({
+            scripts: {
+                'lint:js': '',
+                'lint:ts': '',
+                'lint:fix:js': '',
+                'lint:fix:ts': '',
+            },
+        });
+        expect(parser.parse(createCommandInfo(`${command} lint:*(!fix)`))).toEqual([
+            { name: 'js', command: `${command} lint:js` },
+            { name: 'ts', command: `${command} lint:ts` },
+        ]);
+    });
+    it('caches scripts upon calls', () => {
+        readPackage.mockReturnValue({});
+        parser.parse(createCommandInfo(`${command} foo-*-baz qux`));
+        parser.parse(createCommandInfo(`${command} foo-*-baz qux`));
+        expect(readPackage).toHaveBeenCalledTimes(1);
+    });
+    it("doesn't read Deno config", () => {
+        readPackage.mockReturnValue({});
+        parser.parse(createCommandInfo(`${command} foo-*-baz qux`));
+        expect(readDeno).not.toHaveBeenCalled();
+    });
+});
+describe(`with a 'deno task' prefix`, () => {
+    it('expands to all scripts matching pattern', () => {
+        readDeno.mockReturnValue({
+            tasks: {
+                'foo-bar-baz': '',
+                'foo--baz': '',
+            },
+        });
+        readPackage.mockReturnValue({
+            scripts: {
+                'foo-foo-baz': '',
+            },
+        });
+        expect(parser.parse(createCommandInfo(`deno task foo-*-baz qux`))).toEqual([
+            { name: 'bar', command: `deno task foo-bar-baz qux` },
+            { name: '', command: `deno task foo--baz qux` },
+            { name: 'foo', command: `deno task foo-foo-baz qux` },
+        ]);
+    });
+    it('uses wildcard match of script as command name', () => {
+        readDeno.mockReturnValue({
+            tasks: {
+                'watch-sass': '',
+            },
+        });
+        readPackage.mockReturnValue({
+            scripts: {
+                'watch-js': '',
+                'watch-css': '',
+            },
+        });
+        expect(parser.parse({
+            name: '',
+            command: `deno task watch-*`,
+        })).toEqual([
+            { name: 'sass', command: `deno task watch-sass` },
+            { name: 'js', command: `deno task watch-js` },
+            { name: 'css', command: `deno task watch-css` },
+        ]);
+    });
+    it('uses existing command name as prefix to the wildcard match', () => {
+        readDeno.mockReturnValue({
+            tasks: {
+                'watch-sass': '',
+            },
+        });
+        readPackage.mockReturnValue({
+            scripts: {
+                'watch-js': '',
+                'watch-css': '',
+            },
+        });
+        expect(parser.parse({
+            name: 'w:',
+            command: `deno task watch-*`,
+        })).toEqual([
+            { name: 'w:sass', command: `deno task watch-sass` },
+            { name: 'w:js', command: `deno task watch-js` },
+            { name: 'w:css', command: `deno task watch-css` },
+        ]);
+    });
+    it('allows negation', () => {
+        readDeno.mockReturnValue({
+            tasks: {
+                'lint:sass': '',
+                'lint:fix:sass': '',
+            },
+        });
+        readPackage.mockReturnValue({
+            scripts: {
+                'lint:js': '',
+                'lint:ts': '',
+                'lint:fix:js': '',
+                'lint:fix:ts': '',
+            },
+        });
+        expect(parser.parse(createCommandInfo(`deno task lint:*(!fix)`))).toEqual([
+            { name: 'sass', command: `deno task lint:sass` },
+            { name: 'js', command: `deno task lint:js` },
+            { name: 'ts', command: `deno task lint:ts` },
+        ]);
+    });
+    it('caches scripts upon calls', () => {
+        readDeno.mockReturnValue({});
+        readPackage.mockReturnValue({});
+        parser.parse(createCommandInfo(`deno task foo-*-baz qux`));
+        parser.parse(createCommandInfo(`deno task foo-*-baz qux`));
+        expect(readDeno).toHaveBeenCalledTimes(1);
+        expect(readPackage).toHaveBeenCalledTimes(1);
+    });
+});

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

@@ -1,10 +1,7 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { ChildProcess as BaseChildProcess, MessageOptions, SendHandle, SpawnOptions } from 'child_process';
-import * as Rx from 'rxjs';
-import { EventEmitter, Writable } from 'stream';
+import { Buffer } from 'node:buffer';
+import { ChildProcess as BaseChildProcess, MessageOptions, SendHandle, SpawnOptions } from 'node:child_process';
+import { EventEmitter, Writable } from 'node:stream';
+import Rx from 'rxjs';
 /**
  * Identifier for a command; if string, it's the command's name, if number, it's the index.
  */
@@ -72,7 +69,7 @@ export interface MessageEvent {
 }
 interface OutgoingMessageEvent extends MessageEvent {
     options?: MessageOptions;
-    onSent(error?: unknown): void;
+    onSent: (error?: unknown) => void;
 }
 /**
  * Subtype of NodeJS's child_process including only what's actually needed for a command to work.
@@ -114,8 +111,8 @@ export declare class Command implements CommandInfo {
     readonly ipc?: number;
     readonly close: Rx.Subject<CloseEvent>;
     readonly error: Rx.Subject<unknown>;
-    readonly stdout: Rx.Subject<Buffer>;
-    readonly stderr: Rx.Subject<Buffer>;
+    readonly stdout: Rx.Subject<Buffer<ArrayBufferLike>>;
+    readonly stderr: Rx.Subject<Buffer<ArrayBufferLike>>;
     readonly timer: Rx.Subject<TimerEvent>;
     /**
      * A stream of changes to the `#state` property.

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

@@ -1,31 +1,6 @@
-"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.Command = void 0;
-const Rx = __importStar(require("rxjs"));
-class Command {
+import process from 'node:process';
+import Rx from 'rxjs';
+export class Command {
     killProcess;
     spawn;
     spawnOpts;
@@ -120,10 +95,12 @@ class Command {
                 },
             });
         });
-        child.stdout &&
+        if (child.stdout) {
             pipeTo(Rx.fromEvent(child.stdout, 'data').pipe(Rx.map((event) => event)), this.stdout);
-        child.stderr &&
+        }
+        if (child.stderr) {
             pipeTo(Rx.fromEvent(child.stderr, 'data').pipe(Rx.map((event) => event)), this.stderr);
+        }
         this.stdin = child.stdin || undefined;
     }
     changeState(state) {
@@ -166,7 +143,12 @@ class Command {
                 handle,
                 options,
                 onSent(error) {
-                    error ? reject(error) : resolve();
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve();
+                    }
                 },
             });
         });
@@ -194,7 +176,6 @@ class Command {
         return !!command.pid && !!command.process;
     }
 }
-exports.Command = Command;
 /**
  * Pipes all events emitted by `stream` into `subject`.
  */

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

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