concurrently 8.2.2 → 9.0.1

package/dist/src/date-format.js

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateFormatter = void 0;
+/**
+ * Unicode-compliant date/time formatter.
+ *
+ * @see https://unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns
+ */
+class DateFormatter {
+    options;
+    static tokenRegex = /[A-Z]/i;
+    parts = [];
+    constructor(pattern, options = {}) {
+        this.options = options;
+        let i = 0;
+        while (i < pattern.length) {
+            const char = pattern[i];
+            const { fn, length } = char === "'"
+                ? this.compileLiteral(pattern, i)
+                : DateFormatter.tokenRegex.test(char)
+                    ? this.compileToken(pattern, i)
+                    : this.compileOther(pattern, i);
+            this.parts.push(fn);
+            i += length;
+        }
+    }
+    compileLiteral(pattern, offset) {
+        let length = 1;
+        let value = '';
+        for (; length < pattern.length; length++) {
+            const i = offset + length;
+            const char = pattern[i];
+            if (char === "'") {
+                const nextChar = pattern[i + 1];
+                length++;
+                // if the next character is another single quote, it's been escaped.
+                // if not, then the literal has been closed
+                if (nextChar !== "'") {
+                    break;
+                }
+            }
+            value += char;
+        }
+        return { fn: () => value || "'", length };
+    }
+    compileOther(pattern, offset) {
+        let value = '';
+        while (!DateFormatter.tokenRegex.test(pattern[offset]) && pattern[offset] !== "'") {
+            value += pattern[offset++];
+        }
+        return { fn: () => value, length: value.length };
+    }
+    compileToken(pattern, offset) {
+        const type = pattern[offset];
+        const token = tokens.get(type);
+        if (!token) {
+            throw new SyntaxError(`Formatting token "${type}" is invalid`);
+        }
+        let length = 0;
+        while (pattern[offset + length] === type) {
+            length++;
+        }
+        const tokenFn = token[length - 1];
+        if (!tokenFn) {
+            throw new RangeError(`Formatting token "${type.repeat(length)}" is unsupported`);
+        }
+        return { fn: tokenFn, length };
+    }
+    format(date) {
+        return this.parts.reduce((output, part) => output + String(part(date, this.options)), '');
+    }
+}
+exports.DateFormatter = DateFormatter;
+/**
+ * A map of token to its implementations by length.
+ * If an index is undefined, then that token length is unsupported.
+ */
+const tokens = new Map()
+    // era
+    .set('G', [
+    makeTokenFn({ era: 'short' }, 'era'),
+    makeTokenFn({ era: 'short' }, 'era'),
+    makeTokenFn({ era: 'short' }, 'era'),
+    makeTokenFn({ era: 'long' }, 'era'),
+    makeTokenFn({ era: 'narrow' }, 'era'),
+])
+    // year
+    .set('y', [
+    // TODO: does not support BC years.
+    // https://stackoverflow.com/a/41345095/2083599
+    (date) => date.getFullYear(),
+    (date) => pad(2, date.getFullYear()).slice(-2),
+    (date) => pad(3, date.getFullYear()),
+    (date) => pad(4, date.getFullYear()),
+    (date) => pad(5, date.getFullYear()),
+])
+    .set('Y', [
+    getWeekYear,
+    (date, options) => pad(2, getWeekYear(date, options)).slice(-2),
+    (date, options) => pad(3, getWeekYear(date, options)),
+    (date, options) => pad(4, getWeekYear(date, options)),
+    (date, options) => pad(5, getWeekYear(date, options)),
+])
+    .set('u', [])
+    .set('U', [
+    // Fallback implemented as yearName is not available in gregorian calendars, for instance.
+    makeTokenFn({ dateStyle: 'full' }, 'yearName', (date) => String(date.getFullYear())),
+])
+    .set('r', [
+    // Fallback implemented as relatedYear is not available in gregorian calendars, for instance.
+    makeTokenFn({ dateStyle: 'full' }, 'relatedYear', (date) => String(date.getFullYear())),
+])
+    // quarter
+    .set('Q', [
+    (date) => Math.floor(date.getMonth() / 3) + 1,
+    (date) => pad(2, Math.floor(date.getMonth() / 3) + 1),
+    // these aren't localized in Intl.DateTimeFormat.
+    undefined,
+    undefined,
+    (date) => Math.floor(date.getMonth() / 3) + 1,
+])
+    .set('q', [
+    (date) => Math.floor(date.getMonth() / 3) + 1,
+    (date) => pad(2, Math.floor(date.getMonth() / 3) + 1),
+    // these aren't localized in Intl.DateTimeFormat.
+    undefined,
+    undefined,
+    (date) => Math.floor(date.getMonth() / 3) + 1,
+])
+    // month
+    .set('M', [
+    (date) => date.getMonth() + 1,
+    (date) => pad(2, date.getMonth() + 1),
+    // these include the day so that it forces non-stand-alone month part
+    makeTokenFn({ day: 'numeric', month: 'short' }, 'month'),
+    makeTokenFn({ day: 'numeric', month: 'long' }, 'month'),
+    makeTokenFn({ day: 'numeric', month: 'narrow' }, 'month'),
+])
+    .set('L', [
+    (date) => date.getMonth() + 1,
+    (date) => pad(2, date.getMonth() + 1),
+    makeTokenFn({ month: 'short' }, 'month'),
+    makeTokenFn({ month: 'long' }, 'month'),
+    makeTokenFn({ month: 'narrow' }, 'month'),
+])
+    .set('l', [() => ''])
+    // week
+    .set('w', [getWeek, (date, options) => pad(2, getWeek(date, options))])
+    .set('W', [getWeekOfMonth])
+    // day
+    .set('d', [(date) => date.getDate(), (date) => pad(2, date.getDate())])
+    .set('D', [
+    getDayOfYear,
+    (date) => pad(2, getDayOfYear(date)),
+    (date) => pad(3, getDayOfYear(date)),
+])
+    .set('F', [(date) => Math.ceil(date.getDate() / 7)])
+    .set('g', [])
+    // week day
+    .set('E', [
+    makeTokenFn({ weekday: 'short' }, 'weekday'),
+    makeTokenFn({ weekday: 'short' }, 'weekday'),
+    makeTokenFn({ weekday: 'short' }, 'weekday'),
+    makeTokenFn({ weekday: 'long' }, 'weekday'),
+])
+    .set('e', [
+    undefined,
+    undefined,
+    makeTokenFn({ weekday: 'short' }, 'weekday'),
+    makeTokenFn({ weekday: 'long' }, 'weekday'),
+])
+    .set('c', [])
+    // period
+    .set('a', [
+    makeTokenFn({ hour12: true, timeStyle: 'full' }, 'dayPeriod'),
+    makeTokenFn({ hour12: true, timeStyle: 'full' }, 'dayPeriod'),
+    makeTokenFn({ hour12: true, timeStyle: 'full' }, 'dayPeriod'),
+])
+    .set('b', [])
+    .set('B', [
+    makeTokenFn({ dayPeriod: 'short' }, 'dayPeriod'),
+    makeTokenFn({ dayPeriod: 'short' }, 'dayPeriod'),
+    makeTokenFn({ dayPeriod: 'short' }, 'dayPeriod'),
+    makeTokenFn({ dayPeriod: 'long' }, 'dayPeriod'),
+])
+    // hour
+    .set('h', [(date) => date.getHours() % 12 || 12, (date) => pad(2, date.getHours() % 12 || 12)])
+    .set('H', [(date) => date.getHours(), (date) => pad(2, date.getHours())])
+    .set('K', [(date) => date.getHours() % 12, (date) => pad(2, date.getHours() % 12)])
+    .set('k', [(date) => date.getHours() % 24 || 24, (date) => pad(2, date.getHours() % 24 || 24)])
+    .set('j', [])
+    .set('J', [])
+    .set('C', [])
+    // minute
+    .set('m', [(date) => date.getMinutes(), (date) => pad(2, date.getMinutes())])
+    // second
+    .set('s', [(date) => date.getSeconds(), (date) => pad(2, date.getSeconds())])
+    .set('S', [
+    (date) => Math.trunc(date.getMilliseconds() / 100),
+    (date) => pad(2, Math.trunc(date.getMilliseconds() / 10)),
+    (date) => pad(3, Math.trunc(date.getMilliseconds())),
+])
+    .set('A', [])
+    // zone
+    // none of these have tests
+    .set('z', [
+    makeTokenFn({ timeZoneName: 'short' }, 'timeZoneName'),
+    makeTokenFn({ timeZoneName: 'short' }, 'timeZoneName'),
+    makeTokenFn({ timeZoneName: 'short' }, 'timeZoneName'),
+    makeTokenFn({ timeZoneName: 'long' }, 'timeZoneName'),
+])
+    .set('Z', [
+    undefined,
+    undefined,
+    undefined,
+    // equivalent to `OOOO`.
+    makeTokenFn({ timeZoneName: 'longOffset' }, 'timeZoneName'),
+])
+    .set('O', [
+    makeTokenFn({ timeZoneName: 'shortOffset' }, 'timeZoneName'),
+    undefined,
+    undefined,
+    // equivalent to `ZZZZ`.
+    makeTokenFn({ timeZoneName: 'longOffset' }, 'timeZoneName'),
+])
+    .set('v', [
+    makeTokenFn({ timeZoneName: 'shortGeneric' }, 'timeZoneName'),
+    undefined,
+    undefined,
+    makeTokenFn({ timeZoneName: 'longGeneric' }, 'timeZoneName'),
+])
+    .set('V', [])
+    .set('X', [])
+    .set('x', []);
+let locale;
+function getLocale(options) {
+    if (!locale || locale.baseName !== options.locale) {
+        locale = new Intl.Locale(options.locale || new Intl.DateTimeFormat().resolvedOptions().locale);
+    }
+    return locale;
+}
+/**
+ * Creates a token formatting function that returns the value of the chosen part type,
+ * using the current locale's settings.
+ *
+ * If the date/formatter settings doesn't include the requested part type,
+ * the `fallback` function is invoked, if specified. If none has been specified, returns an
+ * empty string.
+ */
+function makeTokenFn(options, type, fallback) {
+    let formatter;
+    return (date, formatterOptions) => {
+        // Allow tests to set a different locale and have that cause the formatter to be recreated
+        if (!formatter ||
+            formatter.resolvedOptions().locale !== formatterOptions.locale ||
+            formatter.resolvedOptions().calendar !== formatterOptions.calendar) {
+            formatter = new Intl.DateTimeFormat(formatterOptions.locale, {
+                ...options,
+                calendar: options.calendar ?? formatterOptions.calendar,
+            });
+        }
+        const parts = formatter.formatToParts(date);
+        const part = parts.find((p) => p.type === type);
+        return part?.value ?? (fallback ? fallback(date, formatterOptions) : '');
+    };
+}
+function startOfWeek(date, options) {
+    const locale = getLocale(options);
+    const firstDay = locale.weekInfo.firstDay === 7 ? 0 : locale.weekInfo.firstDay;
+    const day = date.getDay();
+    const diff = (day < firstDay ? 7 : 0) + day - firstDay;
+    date.setDate(date.getDate() - diff);
+    date.setHours(0, 0, 0, 0);
+    return date;
+}
+function getWeekYear(date, options) {
+    const locale = getLocale(options);
+    const minimalDays = locale.weekInfo.minimalDays;
+    const year = date.getFullYear();
+    const thisYear = startOfWeek(new Date(year, 0, minimalDays), options);
+    const nextYear = startOfWeek(new Date(year + 1, 0, minimalDays), options);
+    if (date.getTime() >= nextYear.getTime()) {
+        return year + 1;
+    }
+    else if (date.getTime() >= thisYear.getTime()) {
+        return year;
+    }
+    else {
+        return year - 1;
+    }
+}
+function getWeek(date, options) {
+    const locale = getLocale(options);
+    const weekMs = 7 * 24 * 3600 * 1000;
+    const temp = startOfWeek(new Date(date), options);
+    const thisYear = new Date(getWeekYear(date, options), 0, locale.weekInfo.minimalDays);
+    startOfWeek(thisYear, options);
+    const diff = temp.getTime() - thisYear.getTime();
+    return Math.round(diff / weekMs) + 1;
+}
+function getWeekOfMonth(date, options) {
+    const current = new Date(date);
+    current.setHours(0, 0, 0, 0);
+    const monthWeekStart = startOfWeek(new Date(date.getFullYear(), date.getMonth(), 1), options);
+    const weekMs = 7 * 24 * 3600 * 1000;
+    return Math.floor((date.getTime() - monthWeekStart.getTime()) / weekMs) + 1;
+}
+function getDayOfYear(date) {
+    let days = 0;
+    for (let i = 0; i <= date.getMonth() - 1; i++) {
+        const temp = new Date(date.getFullYear(), i + 1, 0, 0, 0, 0);
+        days += temp.getDate();
+    }
+    return days + date.getDate();
+}
+function pad(length, val) {
+    return String(val).padStart(length, '0');
+}

package/dist/src/defaults.d.ts

@@ -44,7 +44,7 @@ export declare const restartDelay = 0;
 export declare const success: SuccessCondition;
 /**
  * Date format used when logging date/time.
- * @see https://date-fns.org/v2.0.1/docs/format
+ * @see https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
  */
 export declare const timestampFormat = "yyyy-MM-dd HH:mm:ss.SSS";
 /**

package/dist/src/defaults.js

@@ -49,7 +49,7 @@ exports.restartDelay = 0;
 exports.success = 'all';
 /**
  * Date format used when logging date/time.
- * @see https://date-fns.org/v2.0.1/docs/format
+ * @see https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
  */
 exports.timestampFormat = 'yyyy-MM-dd HH:mm:ss.SSS';
 /**

package/dist/src/flow-control/flow-controller.d.ts

@@ -8,6 +8,6 @@ import { Command } from '../command';
 export interface FlowController {
     handle(commands: Command[]): {
         commands: Command[];
-        onFinish?: () => void;
+        onFinish?: () => void | Promise<void>;
     };
 }

package/dist/src/flow-control/input-handler.js

@@ -37,6 +37,10 @@ const defaults = __importStar(require("../defaults"));
  * If the input doesn't start with a command identifier, it is then always sent to the default target.
  */
 class InputHandler {
+    logger;
+    defaultInputTarget;
+    inputStream;
+    pauseInputStreamOnFinish;
     constructor({ defaultInputTarget, inputStream, pauseInputStreamOnFinish, logger, }) {
         this.logger = logger;
         this.defaultInputTarget = defaultInputTarget || defaults.defaultInputTarget;

package/dist/src/flow-control/kill-on-signal.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import EventEmitter from 'events';
 import { Command } from '../command';
 import { FlowController } from './flow-controller';
@@ -8,8 +9,10 @@ import { FlowController } from './flow-controller';
  */
 export declare class KillOnSignal implements FlowController {
     private readonly process;
-    constructor({ process }: {
+    private readonly abortController?;
+    constructor({ process, abortController, }: {
         process: EventEmitter;
+        abortController?: AbortController;
     });
     handle(commands: Command[]): {
         commands: Command[];

package/dist/src/flow-control/kill-on-signal.js

@@ -7,14 +7,18 @@ const operators_1 = require("rxjs/operators");
  * command.
  */
 class KillOnSignal {
-    constructor({ process }) {
+    process;
+    abortController;
+    constructor({ process, abortController, }) {
         this.process = process;
+        this.abortController = abortController;
     }
     handle(commands) {
         let caughtSignal;
         ['SIGINT', 'SIGTERM', 'SIGHUP'].forEach((signal) => {
             this.process.on(signal, () => {
                 caughtSignal = signal;
+                this.abortController?.abort();
                 commands.forEach((command) => command.kill(signal));
             });
         });
@@ -24,6 +28,9 @@ class KillOnSignal {
                     const exitCode = caughtSignal === 'SIGINT' ? 0 : exitInfo.exitCode;
                     return { ...exitInfo, exitCode };
                 }));
+                // Return a proxy so that mutations happen on the original Command object.
+                // If either `Object.assign()` or `Object.create()` were used, it'd be hard to
+                // reflect the mutations on Command objects referenced by previous flow controllers.
                 return new Proxy(command, {
                     get(target, prop) {
                         return prop === 'close' ? closeStream : target[prop];

package/dist/src/flow-control/kill-others.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { Command } from '../command';
 import { Logger } from '../logger';
 import { FlowController } from './flow-controller';
@@ -7,10 +8,12 @@ export type ProcessCloseCondition = 'failure' | 'success';
  */
 export declare class KillOthers implements FlowController {
     private readonly logger;
+    private readonly abortController?;
     private readonly conditions;
     private readonly killSignal;
-    constructor({ logger, conditions, killSignal, }: {
+    constructor({ logger, abortController, conditions, killSignal, }: {
         logger: Logger;
+        abortController?: AbortController;
         conditions: ProcessCloseCondition | ProcessCloseCondition[];
         killSignal: string | undefined;
     });

package/dist/src/flow-control/kill-others.js

@@ -11,8 +11,13 @@ const command_1 = require("../command");
  * Sends a SIGTERM signal to all commands when one of the commands exits with a matching condition.
  */
 class KillOthers {
-    constructor({ logger, conditions, killSignal, }) {
+    logger;
+    abortController;
+    conditions;
+    killSignal;
+    constructor({ logger, abortController, conditions, killSignal, }) {
         this.logger = logger;
+        this.abortController = abortController;
         this.conditions = lodash_1.default.castArray(conditions);
         this.killSignal = killSignal;
     }
@@ -23,6 +28,7 @@ class KillOthers {
         }
         const closeStates = commands.map((command) => command.close.pipe((0, operators_1.map)(({ exitCode }) => exitCode === 0 ? 'success' : 'failure'), (0, operators_1.filter)((state) => conditions.includes(state))));
         closeStates.forEach((closeState) => closeState.subscribe(() => {
+            this.abortController?.abort();
             const killableCommands = commands.filter((command) => command_1.Command.canKill(command));
             if (killableCommands.length) {
                 this.logger.logGlobalEvent(`Sending ${this.killSignal || 'SIGTERM'} to other processes..`);

package/dist/src/flow-control/log-error.js

@@ -5,6 +5,7 @@ exports.LogError = void 0;
  * Logs when commands failed executing, e.g. due to the executable not existing in the system.
  */
 class LogError {
+    logger;
     constructor({ logger }) {
         this.logger = logger;
     }

package/dist/src/flow-control/log-exit.js

@@ -5,6 +5,7 @@ exports.LogExit = void 0;
  * Logs the exit code/signal of commands.
  */
 class LogExit {
+    logger;
     constructor({ logger }) {
         this.logger = logger;
     }

package/dist/src/flow-control/log-output.js

@@ -5,6 +5,7 @@ exports.LogOutput = void 0;
  * Logs the stdout and stderr output of commands.
  */
 class LogOutput {
+    logger;
     constructor({ logger }) {
         this.logger = logger;
     }

package/dist/src/flow-control/log-timings.d.ts

@@ -14,7 +14,7 @@ type TimingInfo = {
 export declare class LogTimings implements FlowController {
     static mapCloseEventToTimingInfo({ command, timings, killed, exitCode, }: CloseEvent): TimingInfo;
     private readonly logger?;
-    private readonly timestampFormat;
+    private readonly dateFormatter;
     constructor({ logger, timestampFormat, }: {
         logger?: Logger;
         timestampFormat?: string;

package/dist/src/flow-control/log-timings.js

@@ -28,10 +28,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LogTimings = void 0;
 const assert = __importStar(require("assert"));
-const format_1 = __importDefault(require("date-fns/format"));
 const lodash_1 = __importDefault(require("lodash"));
 const Rx = __importStar(require("rxjs"));
 const operators_1 = require("rxjs/operators");
+const date_format_1 = require("../date-format");
 const defaults = __importStar(require("../defaults"));
 /**
  * Logs timing information about commands as they start/stop and then a summary when all commands finish.
@@ -47,9 +47,11 @@ class LogTimings {
             command: command.command,
         };
     }
+    logger;
+    dateFormatter;
     constructor({ logger, timestampFormat = defaults.timestampFormat, }) {
         this.logger = logger;
-        this.timestampFormat = timestampFormat;
+        this.dateFormatter = new date_format_1.DateFormatter(timestampFormat);
     }
     printExitInfoTimingTable(exitInfos) {
         assert.ok(this.logger);
@@ -71,12 +73,12 @@ class LogTimings {
         commands.forEach((command) => {
             command.timer.subscribe(({ startDate, endDate }) => {
                 if (!endDate) {
-                    const formattedStartDate = (0, format_1.default)(startDate, this.timestampFormat);
+                    const formattedStartDate = this.dateFormatter.format(startDate);
                     logger.logCommandEvent(`${command.command} started at ${formattedStartDate}`, command);
                 }
                 else {
                     const durationMs = endDate.getTime() - startDate.getTime();
-                    const formattedEndDate = (0, format_1.default)(endDate, this.timestampFormat);
+                    const formattedEndDate = this.dateFormatter.format(endDate);
                     logger.logCommandEvent(`${command.command} stopped at ${formattedEndDate} after ${durationMs.toLocaleString()}ms`, command);
                 }
             });

package/dist/src/flow-control/logger-padding.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '../command';
+import { Logger } from '../logger';
+import { FlowController } from './flow-controller';
+export declare class LoggerPadding implements FlowController {
+    private readonly logger;
+    constructor({ logger }: {
+        logger: Logger;
+    });
+    handle(commands: Command[]): {
+        commands: Command[];
+        onFinish: () => void;
+    };
+}

package/dist/src/flow-control/logger-padding.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerPadding = void 0;
+class LoggerPadding {
+    logger;
+    constructor({ logger }) {
+        this.logger = logger;
+    }
+    handle(commands) {
+        // Sometimes there's limited concurrency, so not all commands will spawn straight away.
+        // Compute the prefix length now, which works for all styles but those with a PID.
+        let length = commands.reduce((length, command) => {
+            const content = this.logger.getPrefixContent(command);
+            return Math.max(length, content?.value.length || 0);
+        }, 0);
+        this.logger.setPrefixLength(length);
+        // The length of prefixes is somewhat stable, except for PIDs, which might change when a
+        // process spawns (e.g. PIDs might look like 1, 10 or 100), therefore listen to command starts
+        // and update the prefix length when this happens.
+        const subs = commands.map((command) => command.timer.subscribe((event) => {
+            if (!event.endDate) {
+                const content = this.logger.getPrefixContent(command);
+                length = Math.max(length, content?.value.length || 0);
+                this.logger.setPrefixLength(length);
+            }
+        }));
+        return {
+            commands,
+            onFinish() {
+                subs.forEach((sub) => sub.unsubscribe());
+            },
+        };
+    }
+}
+exports.LoggerPadding = LoggerPadding;

package/dist/src/flow-control/restart-process.d.ts

@@ -2,16 +2,17 @@ import * as Rx from 'rxjs';
 import { Command } from '../command';
 import { Logger } from '../logger';
 import { FlowController } from './flow-controller';
+export type RestartDelay = number | 'exponential';
 /**
  * Restarts commands that fail up to a defined number of times.
  */
 export declare class RestartProcess implements FlowController {
     private readonly logger;
     private readonly scheduler?;
-    readonly delay: number;
+    private readonly delay;
     readonly tries: number;
     constructor({ delay, tries, logger, scheduler, }: {
-        delay?: number;
+        delay?: RestartDelay;
         tries?: number;
         logger: Logger;
         scheduler?: Rx.SchedulerLike;

package/dist/src/flow-control/restart-process.js

@@ -31,9 +31,13 @@ const defaults = __importStar(require("../defaults"));
  * Restarts commands that fail up to a defined number of times.
  */
 class RestartProcess {
+    logger;
+    scheduler;
+    delay;
+    tries;
     constructor({ delay, tries, logger, scheduler, }) {
         this.logger = logger;
-        this.delay = delay != null ? +delay : defaults.restartDelay;
+        this.delay = delay ?? 0;
         this.tries = tries != null ? +tries : defaults.restartTries;
         this.tries = this.tries < 0 ? Infinity : this.tries;
         this.scheduler = scheduler;
@@ -42,12 +46,17 @@ class RestartProcess {
         if (this.tries === 0) {
             return { commands };
         }
+        const delayOperator = (0, operators_1.delayWhen)((_, index) => {
+            const { delay } = this;
+            const value = delay === 'exponential' ? Math.pow(2, index) * 1000 : delay;
+            return Rx.timer(value, this.scheduler);
+        });
         commands
             .map((command) => command.close.pipe((0, operators_1.take)(this.tries), (0, operators_1.takeWhile)(({ exitCode }) => exitCode !== 0)))
             .map((failure, index) => Rx.merge(
         // Delay the emission (so that the restarts happen on time),
         // explicitly telling the subscriber that a restart is needed
-        failure.pipe((0, operators_1.delay)(this.delay, this.scheduler), (0, operators_1.map)(() => true)), 
+        failure.pipe(delayOperator, (0, operators_1.map)(() => true)), 
         // Skip the first N emissions (as these would be duplicates of the above),
         // meaning it will be empty because of success, or failed all N times,
         // and no more restarts should be attempted.
@@ -64,6 +73,9 @@ class RestartProcess {
                     // We let all success codes pass, and failures only after restarting won't happen again
                     return exitCode === 0 || emission >= this.tries;
                 }));
+                // Return a proxy so that mutations happen on the original Command object.
+                // If either `Object.assign()` or `Object.create()` were used, it'd be hard to
+                // reflect the mutations on Command objects referenced by previous flow controllers.
                 return new Proxy(command, {
                     get(target, prop) {
                         return prop === 'close' ? closeStream : target[prop];

package/dist/src/flow-control/teardown.d.ts

@@ -0,0 +1,21 @@
+import { Command, SpawnCommand } from '../command';
+import { Logger } from '../logger';
+import { FlowController } from './flow-controller';
+export declare class Teardown implements FlowController {
+    private readonly logger;
+    private readonly spawn;
+    private readonly teardown;
+    constructor({ logger, spawn, commands, }: {
+        logger: Logger;
+        /**
+         * Which function to use to spawn commands.
+         * Defaults to the same used by the rest of concurrently.
+         */
+        spawn?: SpawnCommand;
+        commands: readonly string[];
+    });
+    handle(commands: Command[]): {
+        commands: Command[];
+        onFinish: () => Promise<void>;
+    };
+}