concurrently 6.5.0 → 7.1.0

package/README.md

@@ -1,6 +1,6 @@
 # Concurrently
 
-[![Build Status](https://github.com/open-cli-tools/concurrently/workflows/Tests/badge.svg)](https://github.com/open-cli-tools/concurrently/actions?workflow=Tests) 
+[![Build Status](https://github.com/open-cli-tools/concurrently/workflows/Tests/badge.svg)](https://github.com/open-cli-tools/concurrently/actions?workflow=Tests)
 [![Coverage Status](https://coveralls.io/repos/github/open-cli-tools/concurrently/badge.svg?branch=master)](https://coveralls.io/github/open-cli-tools/concurrently?branch=master)
 
 [![NPM Badge](https://nodei.co/npm/concurrently.png?downloads=true)](https://www.npmjs.com/package/concurrently)
@@ -15,8 +15,10 @@ Like `npm run watch-js & npm run watch-less` but better.
   - [Why](#why)
   - [Install](#install)
   - [Usage](#usage)
-  - [Programmatic Usage](#programmatic-usage)
+  - [API](#api)
     - [`concurrently(commands[, options])`](#concurrentlycommands-options)
+    - [`Command`](#command)
+    - [`CloseEvent`](#closeevent)
   - [FAQ](#faq)
 
 ## Why
@@ -107,6 +109,26 @@ concurrently -n w: npm:watch-*
 concurrently -n w:js,w:css,w:node "npm run watch-js" "npm run watch-css" "npm run watch-node"
 ```
 
+Exclusion is also supported. Given the following scripts in package.json:
+```javascript
+{
+    // ...
+    "scripts": {
+      "lint:js": "...",
+      "lint:ts": "...",
+      "lint:fix:js": "...",
+      "lint:fix:ts": "...",
+      // ...
+    }
+    // ...
+}
+```
+```bash
+# Running only lint:js and lint:ts
+#   with lint:fix:js and lint:fix:ts excluded
+concurrently "npm:lint:*(!fix)"
+```
+
 Good frontend one-liner example [here](https://github.com/kimmobrunfeldt/dont-copy-paste-this-frontend-template/blob/5cd2bde719654941bdfc0a42c6f1b8e69ae79980/package.json#L9).
 
 Help:
@@ -135,6 +157,10 @@ General
       --hide            Comma-separated list of processes to hide the output.
                         The processes can be identified by their name or index.
                                                           [string] [default: ""]
+  -g, --group           Order the output as if the commands were run
+                        sequentially.                                  [boolean]
+      --timings         Show timing information for all processes
+                                                      [boolean] [default: false]
 
 Prefix styling
   -p, --prefix            Prefix used in logging for each process.
@@ -147,12 +173,12 @@ Prefix styling
                           - Available modifiers: reset, bold, dim, italic,
                           underline, inverse, hidden, strikethrough
                           - Available colors: black, red, green, yellow, blue,
-                          magenta, cyan, white, gray, or any hex values for
-                          colors, eg #23de43
+                          magenta, cyan, white, gray
+                          or any hex values for colors, eg #23de43
                           - Available background colors: bgBlack, bgRed,
                           bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite
                           See https://www.npmjs.com/package/chalk for more
-                          information.            [string] [default: "reset"]
+                          information.               [string] [default: "reset"]
   -l, --prefix-length     Limit how many characters of the command is displayed
                           in prefix. The option can be used to shorten the
                           prefix when it is set to "command"
@@ -161,17 +187,19 @@ Prefix styling
                                    [string] [default: "yyyy-MM-dd HH:mm:ss.SSS"]
 
 Input handling
-  -i, --handle-input      Whether input should be forwarded to the child
-                          processes. See examples for more information.[boolean]
-  --default-input-target  Identifier for child process to which input on stdin
-                          should be sent if not specified at start of input.
-                          Can be either the index or the name of the process.
-                                                                    [default: 0]
+  -i, --handle-input          Whether input should be forwarded to the child
+                              processes. See examples for more information.
+                                                                       [boolean]
+      --default-input-target  Identifier for child process to which input on
+                              stdin should be sent if not specified at start of
+                              input.
+                              Can be either the index or the name of the
+                              process.                              [default: 0]
 
 Killing other processes
-  -k, --kill-others      kill other processes if one exits or dies     [boolean]
-  --kill-others-on-fail  kill other processes if one exits with non zero status
-                         code                                          [boolean]
+  -k, --kill-others          kill other processes if one exits or dies [boolean]
+      --kill-others-on-fail  kill other processes if one exits with non zero
+                             status code                               [boolean]
 
 Restarting
       --restart-tries  How many times a process that died should restart.
@@ -233,7 +261,7 @@ Examples:
 For more details, visit https://github.com/open-cli-tools/concurrently
 ```
 
-## Programmatic Usage
+## API
 concurrently can be used programmatically by using the API documented below:
 
 ### `concurrently(commands[, options])`
@@ -272,17 +300,16 @@ concurrently can be used programmatically by using the API documented below:
     - `timestampFormat`: a [date-fns format](https://date-fns.org/v2.0.1/docs/format)
     to use when prefixing with `time`. Default: `yyyy-MM-dd HH:mm:ss.ZZZ`
 
-> Returns: a `Promise` that resolves if the run was successful (according to `successCondition` option),
-> or rejects, containing an array of objects with information for each command that has been run, in the order
-> that the commands terminated. The objects have the shape `{ command, index, exitCode, killed }`, where `command` is the object
-> passed in the `commands` array, `index` its index there and `killed` indicates if the process was killed as a result of
-> `killOthers`. Default values (empty strings or objects) are returned for the fields that were not specified.
+> **Returns:** an object in the shape `{ result, commands }`.
+> - `result`: a `Promise` that resolves if the run was successful (according to `successCondition` option),
+>   or rejects, containing an array of [`CloseEvent`](#CloseEvent), in the order that the commands terminated.
+> - `commands`: an array of all spawned [`Command`s](#Command).
 
 Example:
 
 ```js
 const concurrently = require('concurrently');
-concurrently([
+const { result } = concurrently([
     'npm:watch-*',
     { command: 'nodemon', name: 'server' },
     { command: 'deploy', name: 'deploy', env: { PUBLIC_KEY: '...' } },
@@ -292,9 +319,42 @@ concurrently([
     killOthers: ['failure', 'success'],
     restartTries: 3,
     cwd: path.resolve(__dirname, 'scripts'),
-}).then(success, failure);
+});
+result.then(success, failure);
 ```
 
+### `Command`
+An object that contains all information about a spawned command, and ways to interact with it.<br>
+It has the following properties:
+
+- `index`: the index of the command among all commands spawned.
+- `command`: the command line of the command.
+- `name`: the name of the command; defaults to an empty string.
+- `cwd`: the current working directory of the command.
+- `env`: an object with all the environment variables that the command will be spawned with.
+- `killed`: whether the command has been killed.
+- `exited`: whether the command exited yet.
+- `pid`: the command's process ID.
+- `stdin`: a Writable stream to the command's `stdin`.
+- `stdout`: an RxJS observable to the command's `stdout`.
+- `stderr`: an RxJS observable to the command's `stderr`.
+- `error`: an RxJS observable to the command's error events (e.g. when it fails to spawn).
+- `timer`: an RxJS observable to the command's timing events (e.g. starting, stopping).
+- `close`: an RxJS observable to the command's close events.
+  See [`CloseEvent`](#CloseEvent) for more information.
+- `start()`: starts the command, setting up all
+- `kill([signal])`: kills the command, optionally specifying a signal (e.g. `SIGTERM`, `SIGKILL`, etc).
+
+### `CloseEvent`
+An object with information about a command's closing event.<br>
+It contains the following properties:
+
+- `command`: a stripped down version of [`Command`](#command), including only `name`, `command`, `env` and `cwd` properties.
+- `index`: the index of the command among all commands spawned.
+- `killed`: whether the command exited because it was killed.
+- `exitCode`: the exit code of the command's process, or the signal which it was killed with.
+- `timings`: an object in the shape `{ startDate, endDate, durationSeconds }`.
+
 ## FAQ
 
 * Process exited with code *null*?

package/dist/bin/concurrently.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/concurrently.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const yargs_1 = __importDefault(require("yargs"));
+const defaults = __importStar(require("../src/defaults"));
+const index_1 = __importDefault(require("../src/index"));
+const epilogue_1 = require("./epilogue");
+const args = yargs_1.default
+    .usage('$0 [options] <command ...>')
+    .help('h')
+    .alias('h', 'help')
+    .version()
+    .alias('version', 'v')
+    .alias('version', 'V')
+    // TODO: Add some tests for this.
+    .env('CONCURRENTLY')
+    .options({
+    // General
+    'max-processes': {
+        alias: 'm',
+        describe: 'How many processes should run at once.\n' +
+            'New processes only spawn after all restart tries of a process.',
+        type: 'number'
+    },
+    'names': {
+        alias: 'n',
+        describe: 'List of custom names to be used in prefix template.\n' +
+            'Example names: "main,browser,server"',
+        type: 'string'
+    },
+    'name-separator': {
+        describe: 'The character to split <names> on. Example usage:\n' +
+            'concurrently -n "styles|scripts|server" --name-separator "|"',
+        default: defaults.nameSeparator,
+    },
+    'success': {
+        alias: 's',
+        describe: 'Return exit code of zero or one based on the success or failure ' +
+            'of the "first" child to terminate, the "last child", or succeed ' +
+            'only if "all" child processes succeed.',
+        choices: ['first', 'last', 'all'],
+        default: defaults.success
+    },
+    'raw': {
+        alias: 'r',
+        describe: 'Output only raw output of processes, disables prettifying ' +
+            'and concurrently coloring.',
+        type: 'boolean'
+    },
+    // This one is provided for free. Chalk reads this itself and removes colours.
+    // https://www.npmjs.com/package/chalk#chalksupportscolor
+    'no-color': {
+        describe: 'Disables colors from logging',
+        type: 'boolean'
+    },
+    'hide': {
+        describe: 'Comma-separated list of processes to hide the output.\n' +
+            'The processes can be identified by their name or index.',
+        default: defaults.hide,
+        type: 'string'
+    },
+    'group': {
+        alias: 'g',
+        describe: 'Order the output as if the commands were run sequentially.',
+        type: 'boolean'
+    },
+    'timings': {
+        describe: 'Show timing information for all processes',
+        type: 'boolean',
+        default: defaults.timings
+    },
+    // Kill others
+    'kill-others': {
+        alias: 'k',
+        describe: 'kill other processes if one exits or dies',
+        type: 'boolean'
+    },
+    'kill-others-on-fail': {
+        describe: 'kill other processes if one exits with non zero status code',
+        type: 'boolean'
+    },
+    // Prefix
+    'prefix': {
+        alias: 'p',
+        describe: 'Prefix used in logging for each process.\n' +
+            'Possible values: index, pid, time, command, name, none, or a template. ' +
+            'Example template: "{time}-{pid}"',
+        defaultDescription: 'index or name (when --names is set)',
+        type: 'string'
+    },
+    'prefix-colors': {
+        alias: 'c',
+        describe: 'Comma-separated list of chalk colors to use on prefixes. ' +
+            'If there are more commands than colors, the last color will be repeated.\n' +
+            '- Available modifiers: reset, bold, dim, italic, underline, inverse, hidden, strikethrough\n' +
+            '- Available colors: black, red, green, yellow, blue, magenta, cyan, white, gray \n' +
+            'or any hex values for colors, eg #23de43\n' +
+            '- Available background colors: bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite\n' +
+            'See https://www.npmjs.com/package/chalk for more information.',
+        default: defaults.prefixColors,
+        type: 'string'
+    },
+    'prefix-length': {
+        alias: 'l',
+        describe: 'Limit how many characters of the command is displayed in prefix. ' +
+            'The option can be used to shorten the prefix when it is set to "command"',
+        default: defaults.prefixLength,
+        type: 'number'
+    },
+    'timestamp-format': {
+        alias: 't',
+        describe: 'Specify the timestamp in moment/date-fns format.',
+        default: defaults.timestampFormat,
+        type: 'string'
+    },
+    // Restarting
+    'restart-tries': {
+        describe: 'How many times a process that died should restart.\n' +
+            'Negative numbers will make the process restart forever.',
+        default: defaults.restartTries,
+        type: 'number'
+    },
+    'restart-after': {
+        describe: 'Delay time to respawn the process, in milliseconds.',
+        default: defaults.restartDelay,
+        type: 'number'
+    },
+    // Input
+    'handle-input': {
+        alias: 'i',
+        describe: 'Whether input should be forwarded to the child processes. ' +
+            'See examples for more information.',
+        type: 'boolean'
+    },
+    'default-input-target': {
+        default: defaults.defaultInputTarget,
+        describe: 'Identifier for child process to which input on stdin ' +
+            'should be sent if not specified at start of input.\n' +
+            'Can be either the index or the name of the process.'
+    }
+})
+    .group(['m', 'n', 'name-separator', 'raw', 's', 'no-color', 'hide', 'group', 'timings'], 'General')
+    .group(['p', 'c', 'l', 't'], 'Prefix styling')
+    .group(['i', 'default-input-target'], 'Input handling')
+    .group(['k', 'kill-others-on-fail'], 'Killing other processes')
+    .group(['restart-tries', 'restart-after'], 'Restarting')
+    .epilogue(epilogue_1.epilogue)
+    .argv;
+const names = (args.names || '').split(args['name-separator']);
+(0, index_1.default)(args._.map((command, index) => ({
+    command: String(command),
+    name: names[index]
+})), {
+    handleInput: args['handle-input'],
+    defaultInputTarget: args['default-input-target'],
+    killOthers: args.killOthers
+        ? ['success', 'failure']
+        : (args.killOthersOnFail ? ['failure'] : []),
+    maxProcesses: args['max-processes'],
+    raw: args.raw,
+    hide: args.hide.split(','),
+    group: args.group,
+    prefix: args.prefix,
+    prefixColors: args['prefix-colors'].split(','),
+    prefixLength: args['prefix-length'],
+    restartDelay: args['restart-after'],
+    restartTries: args['restart-tries'],
+    successCondition: args.success,
+    timestampFormat: args['timestamp-format'],
+    timings: args.timings
+}).result.then(() => process.exit(0), () => process.exit(1));

package/dist/bin/epilogue.d.ts

@@ -0,0 +1 @@
+export declare const epilogue: string;

package/dist/bin/epilogue.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.epilogue = void 0;
+// Add new examples here.
+// Always start with `$ $0` so that it a) symbolizes a command line; and b) $0 gets replaced by the binary name uniformly.
+const examples = [
+    {
+        description: 'Output nothing more than stdout+stderr of child processes',
+        example: '$ $0 --raw "npm run watch-less" "npm run watch-js"'
+    },
+    {
+        description: 'Normal output but without colors e.g. when logging to file',
+        example: '$ $0 --no-color "grunt watch" "http-server" > log'
+    },
+    {
+        description: 'Custom prefix',
+        example: '$ $0 --prefix "{time}-{pid}" "npm run watch" "http-server"',
+    },
+    {
+        description: 'Custom names and colored prefixes',
+        example: '$ $0 --names "HTTP,WATCH" -c "bgBlue.bold,bgMagenta.bold" "http-server" "npm run watch"',
+    },
+    {
+        description: 'Configuring via environment variables with CONCURRENTLY_ prefix',
+        example: '$ CONCURRENTLY_RAW=true CONCURRENTLY_KILL_OTHERS=true $0 "echo hello" "echo world"',
+    },
+    {
+        description: 'Send input to default',
+        example: [
+            '$ $0 --handle-input "nodemon" "npm run watch-js"',
+            'rs  # Sends rs command to nodemon process'
+        ].join('\n'),
+    },
+    {
+        description: 'Send input to specific child identified by index',
+        example: [
+            '$ $0 --handle-input "npm run watch-js" nodemon',
+            '1:rs'
+        ].join('\n'),
+    },
+    {
+        description: 'Send input to specific child identified by name',
+        example: [
+            '$ $0 --handle-input -n js,srv "npm run watch-js" nodemon',
+            'srv:rs'
+        ].join('\n'),
+    },
+    {
+        description: 'Shortened NPM run commands',
+        example: '$ $0 npm:watch-node npm:watch-js npm:watch-css',
+    },
+    {
+        description: 'Shortened NPM run command with wildcard (make sure to wrap it in quotes!)',
+        example: '$ $0 "npm:watch-*"',
+    },
+    {
+        description: 'Exclude patterns so that between "lint:js" and "lint:fix:js", only "lint:js" is ran',
+        example: '$ $0 "npm:*(!fix)"'
+    }
+];
+exports.epilogue = `
+Examples:
+${examples.map(({ example, description }) => `
+ - ${description}
+
+${example.split('\n').map(line => `     ${line}`).join('\n')}
+`).join('')}
+For more details, visit https://github.com/open-cli-tools/concurrently
+`;

package/dist/src/command-parser/command-parser.d.ts

@@ -0,0 +1,19 @@
+import { CommandInfo } from '../command';
+/**
+ * A command parser encapsulates a specific logic for mapping `CommandInfo` objects
+ * into another `CommandInfo`.
+ *
+ * A prime example is turning an abstract `npm:foo` into `npm run foo`, but it could also turn
+ * the prefix color of a command brighter, or maybe even prefixing each command with `time(1)`.
+ */
+export interface CommandParser {
+    /**
+     * Parses `commandInfo` and returns one or more `CommandInfo`s.
+     *
+     * Returning multiple `CommandInfo` is used when there are multiple possibilities of commands to
+     * run given the original input.
+     * An example of this is when the command contains a wildcard and it must be expanded into all
+     * viable options so that the consumer can decide which ones to run.
+     */
+    parse(commandInfo: CommandInfo): CommandInfo | CommandInfo[];
+}

package/dist/src/command-parser/command-parser.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/command-parser/expand-npm-shortcut.d.ts

@@ -0,0 +1,8 @@
+import { CommandInfo } from '../command';
+import { CommandParser } from './command-parser';
+/**
+ * Expands commands prefixed with `npm:`, `yarn:` or `pnpm:` into the full version `npm run <command>` and so on.
+ */
+export declare class ExpandNpmShortcut implements CommandParser {
+    parse(commandInfo: CommandInfo): CommandInfo;
+}

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

@@ -1,13 +1,20 @@
-module.exports = class ExpandNpmShortcut {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpandNpmShortcut = void 0;
+/**
+ * Expands commands prefixed with `npm:`, `yarn:` or `pnpm:` into the full version `npm run <command>` and so on.
+ */
+class ExpandNpmShortcut {
     parse(commandInfo) {
         const [, npmCmd, cmdName, args] = commandInfo.command.match(/^(npm|yarn|pnpm):(\S+)(.*)/) || [];
         if (!cmdName) {
             return commandInfo;
         }
-
         return Object.assign({}, commandInfo, {
             name: commandInfo.name || cmdName,
             command: `${npmCmd} run ${cmdName}${args}`
         });
     }
-};
+}
+exports.ExpandNpmShortcut = ExpandNpmShortcut;
+;

package/dist/src/command-parser/expand-npm-wildcard.d.ts

@@ -0,0 +1,13 @@
+import { CommandInfo } from '../command';
+import { CommandParser } from './command-parser';
+/**
+ * Finds wildcards in npm/yarn/pnpm run commands and replaces them with all matching scripts in the
+ * `package.json` file of the current directory.
+ */
+export declare class ExpandNpmWildcard implements CommandParser {
+    private readonly readPackage;
+    static readPackage(): any;
+    private scripts?;
+    constructor(readPackage?: typeof ExpandNpmWildcard.readPackage);
+    parse(commandInfo: CommandInfo): CommandInfo | CommandInfo[];
+}

package/dist/src/command-parser/expand-npm-wildcard.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.ExpandNpmWildcard = void 0;
+const fs = __importStar(require("fs"));
+const _ = __importStar(require("lodash"));
+const OMISSION = /\(!([^\)]+)\)/;
+/**
+ * Finds wildcards in npm/yarn/pnpm run commands and replaces them with all matching scripts in the
+ * `package.json` file of the current directory.
+ */
+class ExpandNpmWildcard {
+    constructor(readPackage = ExpandNpmWildcard.readPackage) {
+        this.readPackage = readPackage;
+    }
+    static readPackage() {
+        try {
+            const json = fs.readFileSync('package.json', { encoding: 'utf-8' });
+            return JSON.parse(json);
+        }
+        catch (e) {
+            return {};
+        }
+    }
+    parse(commandInfo) {
+        const [, npmCmd, cmdName, args] = commandInfo.command.match(/(npm|yarn|pnpm) run (\S+)([^&]*)/) || [];
+        const wildcardPosition = (cmdName || '').indexOf('*');
+        // If the regex didn't match an npm script, or it has no wildcard,
+        // then we have nothing to do here
+        if (!cmdName || wildcardPosition === -1) {
+            return commandInfo;
+        }
+        if (!this.scripts) {
+            this.scripts = Object.keys(this.readPackage().scripts || {});
+        }
+        const omissionRegex = cmdName.match(OMISSION);
+        const cmdNameSansOmission = cmdName.replace(OMISSION, '');
+        const preWildcard = _.escapeRegExp(cmdNameSansOmission.substr(0, wildcardPosition));
+        const postWildcard = _.escapeRegExp(cmdNameSansOmission.substr(wildcardPosition + 1));
+        const wildcardRegex = new RegExp(`^${preWildcard}(.*?)${postWildcard}$`);
+        const currentName = commandInfo.name || '';
+        return this.scripts
+            .map(script => {
+            const match = script.match(wildcardRegex);
+            if (omissionRegex) {
+                const toOmit = script.match(new RegExp(omissionRegex[1]));
+                if (toOmit) {
+                    return;
+                }
+            }
+            if (match) {
+                return Object.assign({}, commandInfo, {
+                    command: `${npmCmd} run ${script}${args}`,
+                    // Will use an empty command name if command has no name and the wildcard match is empty,
+                    // e.g. if `npm:watch-*` matches `npm run watch-`.
+                    name: currentName + match[1],
+                });
+            }
+        })
+            .filter((commandInfo) => !!commandInfo);
+    }
+}
+exports.ExpandNpmWildcard = ExpandNpmWildcard;
+;

package/dist/src/command-parser/strip-quotes.d.ts

@@ -0,0 +1,10 @@
+import { CommandInfo } from '../command';
+import { CommandParser } from './command-parser';
+/**
+ * Strips quotes around commands so that they can run on the current shell.
+ */
+export declare class StripQuotes implements CommandParser {
+    parse(commandInfo: CommandInfo): CommandInfo & {
+        command: string;
+    };
+}

package/{src → dist/src}/command-parser/strip-quotes.js

@@ -1,12 +1,18 @@
-module.exports = class StripQuotes {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StripQuotes = void 0;
+/**
+ * Strips quotes around commands so that they can run on the current shell.
+ */
+class StripQuotes {
     parse(commandInfo) {
         let { command } = commandInfo;
-
         // Removes the quotes surrounding a command.
         if (/^"(.+?)"$/.test(command) || /^'(.+?)'$/.test(command)) {
             command = command.substr(1, command.length - 2);
         }
-
         return Object.assign({}, commandInfo, { command });
     }
-};
+}
+exports.StripQuotes = StripQuotes;
+;