concurrently 6.5.1 → 7.2.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,34 +109,68 @@ 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:
 
 ```
-
 concurrently [options] <command ...>
 
 General
-  -m, --max-processes   How many processes should run at once.
-                        New processes only spawn after all restart tries of a
-                        process.                                        [number]
-  -n, --names           List of custom names to be used in prefix template.
-                        Example names: "main,browser,server"            [string]
-      --name-separator  The character to split <names> on. Example usage:
-                        concurrently -n "styles|scripts|server" --name-separator
-                        "|"                                       [default: ","]
-  -r, --raw             Output only raw output of processes, disables
-                        prettifying and concurrently coloring.         [boolean]
-  -s, --success         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: "all"]
-      --no-color        Disables colors from logging                   [boolean]
-      --hide            Comma-separated list of processes to hide the output.
-                        The processes can be identified by their name or index.
-                                                          [string] [default: ""]
+  -m, --max-processes          How many processes should run at once.
+                               New processes only spawn after all restart tries
+                               of a process.                            [number]
+  -n, --names                  List of custom names to be used in prefix
+                               template.
+                               Example names: "main,browser,server"     [string]
+      --name-separator         The character to split <names> on. Example usage:
+                               concurrently -n "styles|scripts|server"
+                               --name-separator "|"               [default: ","]
+  -s, --success                Which command(s) must exit with code 0 in order
+                               for concurrently exit with code 0 too. Options
+                               are:
+                               - "first" for the first command to exit;
+                               - "last" for the last command to exit;
+                               - "all" for all commands;
+                               - "command-{name}"/"command-{index}" for the
+                               commands with that name or index;
+                               - "!command-{name}"/"!command-{index}" for all
+                               commands but the ones with that name or index.
+                                                                [default: "all"]
+  -r, --raw                    Output only raw output of processes, disables
+                               prettifying and concurrently coloring.  [boolean]
+      --no-color               Disables colors from logging            [boolean]
+      --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]
+  -P, --passthrough-arguments  Passthrough additional arguments to commands
+                               (accessible via placeholders) instead of treating
+                               them as commands.      [boolean] [default: false]
 
 Prefix styling
   -p, --prefix            Prefix used in logging for each process.
@@ -147,12 +183,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 +197,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.
@@ -184,6 +222,7 @@ Options:
   -h, --help         Show help                                         [boolean]
   -v, -V, --version  Show version number                               [boolean]
 
+
 Examples:
 
  - Output nothing more than stdout+stderr of child processes
@@ -205,7 +244,8 @@ Examples:
 
  - Configuring via environment variables with CONCURRENTLY_ prefix
 
-     $ CONCURRENTLY_RAW=true CONCURRENTLY_KILL_OTHERS=true concurrently "echo hello" "echo world"
+     $ CONCURRENTLY_RAW=true CONCURRENTLY_KILL_OTHERS=true concurrently "echo
+     hello" "echo world"
 
  - Send input to default
 
@@ -230,10 +270,27 @@ Examples:
 
      $ concurrently "npm:watch-*"
 
+ - Exclude patterns so that between "lint:js" and "lint:fix:js", only "lint:js"
+ is ran
+
+     $ concurrently "npm:*(!fix)"
+
+ - Passthrough some additional arguments via '{<number>}' placeholder
+
+     $ concurrently -P "echo {1}" -- foo
+
+ - Passthrough all additional arguments via '{@}' placeholder
+
+     $ concurrently -P "npm:dev-* -- {@}" -- --watch --noEmit
+
+ - Passthrough all additional arguments combined via '{*}' placeholder
+
+     $ concurrently -P "npm:dev-* -- {*}" -- --watch --noEmit
+
 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])`
@@ -271,18 +328,18 @@ concurrently can be used programmatically by using the API documented below:
     - `restartDelay`: how many milliseconds to wait between process restarts. Default: `0`.
     - `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`
+    - `additionalArguments`: list of additional arguments passed that will get replaced in each command. If not defined, no argument replacing will happen.
 
-> 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 +349,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,218 @@
+#!/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 helpers_1 = require("yargs/helpers");
+const defaults = __importStar(require("../src/defaults"));
+const index_1 = __importDefault(require("../src/index"));
+const epilogue_1 = require("./epilogue");
+// Clean-up arguments (yargs expects only the arguments after the program name)
+const cleanArgs = (0, helpers_1.hideBin)(process.argv);
+// Find argument separator (double dash)
+const argsSepIdx = cleanArgs.findIndex((arg) => arg === '--');
+// Arguments before separator
+const argsBeforeSep = argsSepIdx >= 0 ? cleanArgs.slice(0, argsSepIdx) : cleanArgs;
+// Arguments after separator
+const argsAfterSep = argsSepIdx >= 0 ? cleanArgs.slice(argsSepIdx + 1) : [];
+const args = (0, yargs_1.default)(argsBeforeSep)
+    .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: 'Which command(s) must exit with code 0 in order for concurrently exit with ' +
+            'code 0 too. Options are:\n' +
+            '- "first" for the first command to exit;\n' +
+            '- "last" for the last command to exit;\n' +
+            '- "all" for all commands;\n' +
+            // Note: not a typo. Multiple commands can have the same name.
+            '- "command-{name}"/"command-{index}" for the commands with that name or index;\n' +
+            '- "!command-{name}"/"!command-{index}" for all commands but the ones with that ' +
+            'name or index.\n',
+        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,
+    },
+    'passthrough-arguments': {
+        alias: 'P',
+        describe: 'Passthrough additional arguments to commands (accessible via placeholders) ' +
+            'instead of treating them as commands.',
+        type: 'boolean',
+        default: defaults.passthroughArguments,
+    },
+    // 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', 's', 'r', 'no-color', 'hide', 'g', 'timings', 'P'], '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)
+    .parseSync();
+// Get names of commands by the specified separator
+const names = (args.names || '').split(args.nameSeparator);
+// If "passthrough-arguments" is disabled, treat additional arguments as commands
+const commands = args.passthroughArguments ? args._ : [...args._, ...argsAfterSep];
+(0, index_1.default)(commands.map((command, index) => ({
+    command: String(command),
+    name: names[index],
+})), {
+    handleInput: args.handleInput,
+    defaultInputTarget: args.defaultInputTarget,
+    killOthers: args.killOthers
+        ? ['success', 'failure']
+        : (args.killOthersOnFail ? ['failure'] : []),
+    maxProcesses: args.maxProcesses,
+    raw: args.raw,
+    hide: args.hide.split(','),
+    group: args.group,
+    prefix: args.prefix,
+    prefixColors: args.prefixColors.split(','),
+    prefixLength: args.prefixLength,
+    restartDelay: args.restartAfter,
+    restartTries: args.restartTries,
+    successCondition: args.success,
+    timestampFormat: args.timestampFormat,
+    timings: args.timings,
+    additionalArguments: args.passthroughArguments ? argsAfterSep : undefined,
+}).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,81 @@
+"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)"',
+    },
+    {
+        description: 'Passthrough some additional arguments via \'{<number>}\' placeholder',
+        example: '$ $0 -P "echo {1}" -- foo',
+    },
+    {
+        description: 'Passthrough all additional arguments via \'{@}\' placeholder',
+        example: '$ $0 -P "npm:dev-* -- {@}" -- --watch --noEmit',
+    },
+    {
+        description: 'Passthrough all additional arguments combined via \'{*}\' placeholder',
+        example: '$ $0 -P "npm:dev-* -- {*}" -- --watch --noEmit',
+    },
+];
+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-arguments.d.ts

@@ -0,0 +1,12 @@
+import { CommandInfo } from '../command';
+import { CommandParser } from './command-parser';
+/**
+ * Replace placeholders with additional arguments.
+ */
+export declare class ExpandArguments implements CommandParser {
+    private readonly additionalArguments;
+    constructor(additionalArguments: string[]);
+    parse(commandInfo: CommandInfo): CommandInfo & {
+        command: string;
+    };
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpandArguments = void 0;
+const shell_quote_1 = require("shell-quote");
+/**
+ * Replace placeholders with additional arguments.
+ */
+class ExpandArguments {
+    constructor(additionalArguments) {
+        this.additionalArguments = additionalArguments;
+    }
+    parse(commandInfo) {
+        const command = commandInfo.command.replace(/\\?\{([@\*]|[1-9][0-9]*)\}/g, (match, placeholderTarget) => {
+            // Don't replace the placeholder if it is escaped by a backslash.
+            if (match.startsWith('\\')) {
+                return match.substring(1);
+            }
+            // Replace numeric placeholder if value exists in additional arguments.
+            if (!isNaN(placeholderTarget) &&
+                placeholderTarget <= this.additionalArguments.length) {
+                return (0, shell_quote_1.quote)([this.additionalArguments[placeholderTarget - 1]]);
+            }
+            // Replace all arguments placeholder.
+            if (placeholderTarget === '@') {
+                return (0, shell_quote_1.quote)(this.additionalArguments);
+            }
+            // Replace combined arguments placeholder.
+            if (placeholderTarget === '*') {
+                return (0, shell_quote_1.quote)([this.additionalArguments.join(' ')]);
+            }
+            // Replace placeholder with empty string
+            // if value doesn't exist in additional arguments.
+            return '';
+        });
+        return Object.assign({}, commandInfo, {
+            command,
+        });
+    }
+}
+exports.ExpandArguments = ExpandArguments;

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;
+}