@ohos-ports/nx 17.3.2-beta.0

package/src/tasks-runner/life-cycles/dynamic-run-many-terminal-output-life-cycle.js

@@ -0,0 +1,345 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRunManyDynamicOutputRenderer = void 0;
+const cliCursor = require("cli-cursor");
+const cli_spinners_1 = require("cli-spinners");
+const os_1 = require("os");
+const readline = require("readline");
+const output_1 = require("../../utils/output");
+const pretty_time_1 = require("./pretty-time");
+const formatting_utils_1 = require("./formatting-utils");
+const view_logs_utils_1 = require("./view-logs-utils");
+/**
+ * The following function is responsible for creating a life cycle with dynamic
+ * outputs, meaning previous outputs can be rewritten or modified as new outputs
+ * are added. It is therefore intended for use on a user's local machines.
+ *
+ * In CI environments the static equivalent of this life cycle should be used.
+ *
+ * NOTE: output.dim() should be preferred over output.colors.gray() because it
+ * is much more consistently readable across different terminal color themes.
+ */
+async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, overrides, }) {
+    cliCursor.hide();
+    let resolveRenderIsDonePromise;
+    const renderIsDone = new Promise((resolve) => (resolveRenderIsDonePromise = resolve)).then(() => {
+        clearRenderInterval();
+        cliCursor.show();
+    });
+    function clearRenderInterval() {
+        if (renderIntervalId) {
+            clearInterval(renderIntervalId);
+        }
+    }
+    process.on('exit', () => clearRenderInterval());
+    process.on('SIGINT', () => clearRenderInterval());
+    process.on('SIGTERM', () => clearRenderInterval());
+    process.on('SIGHUP', () => clearRenderInterval());
+    const lifeCycle = {};
+    const isVerbose = overrides.verbose === true;
+    const start = process.hrtime();
+    const figures = await Promise.resolve().then(() => require('figures'));
+    const targets = args.targets;
+    const totalTasks = tasks.length;
+    const taskRows = tasks.map((task) => {
+        return {
+            task,
+            status: 'pending',
+        };
+    });
+    const failedTasks = new Set();
+    const tasksToTerminalOutputs = {};
+    const tasksToProcessStartTimes = {};
+    let hasTaskOutput = false;
+    let pinnedFooterNumLines = 0;
+    let totalCompletedTasks = 0;
+    let totalSuccessfulTasks = 0;
+    let totalFailedTasks = 0;
+    let totalCachedTasks = 0;
+    // Used to control the rendering of the spinner on each project row
+    let currentFrame = 0;
+    let renderIntervalId;
+    const moveCursorToStartOfPinnedFooter = () => {
+        readline.moveCursor(process.stdout, 0, -pinnedFooterNumLines);
+    };
+    const renderPinnedFooter = (lines, dividerColor = 'cyan') => {
+        let additionalLines = 0;
+        if (hasTaskOutput) {
+            const dividerLines = output_1.output.getVerticalSeparatorLines(dividerColor);
+            for (const line of dividerLines) {
+                output_1.output.overwriteLine(line);
+            }
+            additionalLines += dividerLines.length;
+        }
+        // Create vertical breathing room for cursor position under the pinned footer
+        lines.push('');
+        for (const line of lines) {
+            output_1.output.overwriteLine(output_1.output.X_PADDING + line);
+        }
+        pinnedFooterNumLines = lines.length + additionalLines;
+        // clear any possible text below the cursor's position
+        readline.clearScreenDown(process.stdout);
+    };
+    const printTaskResult = (task, status) => {
+        moveCursorToStartOfPinnedFooter();
+        // If this is the very first output, add some vertical breathing room
+        if (!hasTaskOutput) {
+            output_1.output.addNewline();
+        }
+        hasTaskOutput = true;
+        switch (status) {
+            case 'local-cache':
+                writeCompletedTaskResultLine(`${output_1.output.colors.green(figures.tick) +
+                    '  ' +
+                    output_1.output.formatCommand(task.id)}  ${output_1.output.dim('[local cache]')}`);
+                if (isVerbose) {
+                    writeCommandOutputBlock(tasksToTerminalOutputs[task.id]);
+                }
+                break;
+            case 'local-cache-kept-existing':
+                writeCompletedTaskResultLine(`${output_1.output.colors.green(figures.tick) +
+                    '  ' +
+                    output_1.output.formatCommand(task.id)}  ${output_1.output.dim('[existing outputs match the cache, left as is]')}`);
+                if (isVerbose) {
+                    writeCommandOutputBlock(tasksToTerminalOutputs[task.id]);
+                }
+                break;
+            case 'remote-cache':
+                writeCompletedTaskResultLine(`${output_1.output.colors.green(figures.tick) +
+                    '  ' +
+                    output_1.output.formatCommand(task.id)}  ${output_1.output.dim('[remote cache]')}`);
+                if (isVerbose) {
+                    writeCommandOutputBlock(tasksToTerminalOutputs[task.id]);
+                }
+                break;
+            case 'success': {
+                const timeTakenText = (0, pretty_time_1.prettyTime)(process.hrtime(tasksToProcessStartTimes[task.id]));
+                writeCompletedTaskResultLine(output_1.output.colors.green(figures.tick) +
+                    '  ' +
+                    output_1.output.formatCommand(task.id) +
+                    output_1.output.dim(` (${timeTakenText})`));
+                if (isVerbose) {
+                    writeCommandOutputBlock(tasksToTerminalOutputs[task.id]);
+                }
+                break;
+            }
+            case 'failure':
+                output_1.output.addNewline();
+                writeCompletedTaskResultLine(output_1.output.colors.red(figures.cross) +
+                    '  ' +
+                    output_1.output.formatCommand(output_1.output.colors.red(task.id)));
+                writeCommandOutputBlock(tasksToTerminalOutputs[task.id]);
+                break;
+        }
+        delete tasksToTerminalOutputs[task.id];
+        renderPinnedFooter([]);
+        renderRows();
+    };
+    const renderRows = () => {
+        const max = cli_spinners_1.dots.frames.length - 1;
+        const curr = currentFrame;
+        currentFrame = curr >= max ? 0 : curr + 1;
+        const additionalFooterRows = [''];
+        const runningTasks = taskRows.filter((row) => row.status === 'running');
+        const remainingTasks = totalTasks - totalCompletedTasks;
+        if (runningTasks.length > 0) {
+            additionalFooterRows.push(output_1.output.dim(`   ${output_1.output.colors.cyan(figures.arrowRight)}    Executing ${runningTasks.length}/${remainingTasks} remaining tasks${runningTasks.length > 1 ? ' in parallel' : ''}...`));
+            additionalFooterRows.push('');
+            for (const runningTask of runningTasks) {
+                additionalFooterRows.push(`   ${output_1.output.dim.cyan(cli_spinners_1.dots.frames[currentFrame])}    ${output_1.output.formatCommand(runningTask.task.id)}`);
+            }
+            /**
+             * Reduce layout thrashing by ensuring that there is a relatively consistent
+             * height for the area in which the task rows are rendered.
+             *
+             * We can look at the parallel flag to know how many rows are likely to be
+             * needed in the common case and always render that at least that many.
+             */
+            if (totalCompletedTasks !== totalTasks &&
+                Number.isInteger(args.parallel) &&
+                runningTasks.length < args.parallel) {
+                // Don't bother with this optimization if there are fewer tasks remaining than rows required
+                if (remainingTasks >= args.parallel) {
+                    for (let i = runningTasks.length; i < args.parallel; i++) {
+                        additionalFooterRows.push('');
+                    }
+                }
+            }
+        }
+        if (totalSuccessfulTasks > 0 || totalFailedTasks > 0) {
+            additionalFooterRows.push('');
+        }
+        if (totalSuccessfulTasks > 0) {
+            additionalFooterRows.push(`   ${output_1.output.colors.green(figures.tick)}    ${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`);
+        }
+        if (totalFailedTasks > 0) {
+            additionalFooterRows.push(`   ${output_1.output.colors.red(figures.cross)}    ${totalFailedTasks}${`/${totalCompletedTasks}`} failed`);
+        }
+        moveCursorToStartOfPinnedFooter();
+        if (additionalFooterRows.length > 1) {
+            const text = `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
+            const taskOverridesRows = [];
+            if (Object.keys(overrides).length > 0) {
+                const leftPadding = `${output_1.output.X_PADDING}       `;
+                taskOverridesRows.push('');
+                taskOverridesRows.push(`${leftPadding}${output_1.output.dim.cyan('With additional flags:')}`);
+                Object.entries(overrides)
+                    .map(([flag, value]) => output_1.output.dim.cyan((0, formatting_utils_1.formatFlags)(leftPadding, flag, value)))
+                    .forEach((arg) => taskOverridesRows.push(arg));
+            }
+            const pinnedFooterLines = [
+                output_1.output.applyNxPrefix('cyan', output_1.output.colors.cyan(text)),
+                ...taskOverridesRows,
+                ...additionalFooterRows,
+            ];
+            // Vertical breathing room when there isn't yet any output or divider
+            if (!hasTaskOutput) {
+                pinnedFooterLines.unshift('');
+            }
+            renderPinnedFooter(pinnedFooterLines);
+        }
+        else {
+            renderPinnedFooter([]);
+        }
+    };
+    lifeCycle.startCommand = () => {
+        if (projectNames.length <= 0) {
+            renderPinnedFooter([
+                '',
+                output_1.output.applyNxPrefix('gray', `No projects with ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)} were run`),
+            ]);
+            resolveRenderIsDonePromise();
+            return;
+        }
+        renderPinnedFooter([]);
+    };
+    lifeCycle.endCommand = () => {
+        clearRenderInterval();
+        const timeTakenText = (0, pretty_time_1.prettyTime)(process.hrtime(start));
+        moveCursorToStartOfPinnedFooter();
+        if (totalSuccessfulTasks === totalTasks) {
+            const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
+            const taskOverridesRows = [];
+            if (Object.keys(overrides).length > 0) {
+                const leftPadding = `${output_1.output.X_PADDING}       `;
+                taskOverridesRows.push('');
+                taskOverridesRows.push(`${leftPadding}${output_1.output.dim.green('With additional flags:')}`);
+                Object.entries(overrides)
+                    .map(([flag, value]) => output_1.output.dim.green((0, formatting_utils_1.formatFlags)(leftPadding, flag, value)))
+                    .forEach((arg) => taskOverridesRows.push(arg));
+            }
+            const pinnedFooterLines = [
+                output_1.output.applyNxPrefix('green', output_1.output.colors.green(text) + output_1.output.dim.white(` (${timeTakenText})`)),
+                ...taskOverridesRows,
+            ];
+            if (totalCachedTasks > 0) {
+                pinnedFooterLines.push(output_1.output.dim(`${os_1.EOL}   Nx read the output from the cache instead of running the command for ${totalCachedTasks} out of ${totalTasks} tasks.`));
+            }
+            renderPinnedFooter(pinnedFooterLines, 'green');
+        }
+        else {
+            const text = `Ran ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
+            const taskOverridesRows = [];
+            if (Object.keys(overrides).length > 0) {
+                const leftPadding = `${output_1.output.X_PADDING}       `;
+                taskOverridesRows.push('');
+                taskOverridesRows.push(`${leftPadding}${output_1.output.dim.red('With additional flags:')}`);
+                Object.entries(overrides)
+                    .map(([flag, value]) => output_1.output.dim.red((0, formatting_utils_1.formatFlags)(leftPadding, flag, value)))
+                    .forEach((arg) => taskOverridesRows.push(arg));
+            }
+            const numFailedToPrint = 5;
+            const failedTasksForPrinting = Array.from(failedTasks).slice(0, numFailedToPrint);
+            const failureSummaryRows = [
+                output_1.output.applyNxPrefix('red', output_1.output.colors.red(text) + output_1.output.dim.white(` (${timeTakenText})`)),
+                ...taskOverridesRows,
+                '',
+                output_1.output.dim(`   ${output_1.output.dim(figures.tick)}    ${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`),
+                '',
+                `   ${output_1.output.colors.red(figures.cross)}    ${totalFailedTasks}${`/${totalCompletedTasks}`} targets failed, including the following:`,
+                `${failedTasksForPrinting
+                    .map((t) => `        ${output_1.output.colors.red('-')} ${output_1.output.formatCommand(t.toString())}`)
+                    .join('\n ')}`,
+            ];
+            if (failedTasks.size > numFailedToPrint) {
+                failureSummaryRows.push(output_1.output.dim(`        ...and ${failedTasks.size - numFailedToPrint} more...`));
+            }
+            failureSummaryRows.push(...(0, view_logs_utils_1.viewLogsFooterRows)(failedTasks.size));
+            renderPinnedFooter(failureSummaryRows, 'red');
+        }
+        resolveRenderIsDonePromise();
+    };
+    lifeCycle.startTasks = (tasks) => {
+        for (const task of tasks) {
+            tasksToProcessStartTimes[task.id] = process.hrtime();
+        }
+        for (const taskRow of taskRows) {
+            if (tasks.indexOf(taskRow.task) > -1) {
+                taskRow.status = 'running';
+            }
+        }
+        if (!renderIntervalId) {
+            renderIntervalId = setInterval(renderRows, 100);
+        }
+    };
+    lifeCycle.printTaskTerminalOutput = (task, _cacheStatus, output) => {
+        tasksToTerminalOutputs[task.id] = output;
+    };
+    lifeCycle.endTasks = (taskResults) => {
+        for (let t of taskResults) {
+            totalCompletedTasks++;
+            const matchingTaskRow = taskRows.find((r) => r.task.id === t.task.id);
+            if (matchingTaskRow) {
+                matchingTaskRow.status = t.status;
+            }
+            switch (t.status) {
+                case 'remote-cache':
+                case 'local-cache':
+                case 'local-cache-kept-existing':
+                    totalCachedTasks++;
+                    totalSuccessfulTasks++;
+                    break;
+                case 'success':
+                    totalSuccessfulTasks++;
+                    break;
+                case 'failure':
+                    totalFailedTasks++;
+                    failedTasks.add(t.task.id);
+                    break;
+            }
+            printTaskResult(t.task, t.status);
+        }
+    };
+    return { lifeCycle, renderIsDone };
+}
+exports.createRunManyDynamicOutputRenderer = createRunManyDynamicOutputRenderer;
+function writeCompletedTaskResultLine(line) {
+    const additionalXPadding = '   ';
+    output_1.output.overwriteLine(output_1.output.X_PADDING + additionalXPadding + line);
+}
+/**
+ * There's not much we can do in order to "neaten up" the outputs of
+ * commands we do not control, but at the very least we can trim any
+ * leading whitespace and any _excess_ trailing newlines so that there
+ * isn't unncecessary vertical whitespace.
+ */
+function writeCommandOutputBlock(commandOutput) {
+    commandOutput = commandOutput || '';
+    commandOutput = commandOutput.trimStart();
+    const additionalXPadding = '      ';
+    const lines = commandOutput.split(os_1.EOL);
+    let totalTrailingEmptyLines = 0;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (lines[i] !== '') {
+            break;
+        }
+        totalTrailingEmptyLines++;
+    }
+    if (totalTrailingEmptyLines > 1) {
+        const linesToRemove = totalTrailingEmptyLines - 1;
+        lines.splice(lines.length - linesToRemove, linesToRemove);
+    }
+    lines.push('');
+    // Indent the command output to make it look more "designed" in the context of the dynamic output
+    lines.forEach((l) => output_1.output.overwriteLine(`${output_1.output.X_PADDING}${additionalXPadding}${l}`));
+}

package/src/tasks-runner/life-cycles/dynamic-run-one-terminal-output-life-cycle.d.ts

@@ -0,0 +1,24 @@
+import type { LifeCycle } from '../life-cycle';
+import { Task } from '../../config/task-graph';
+/**
+ * The following function is responsible for creating a life cycle with dynamic
+ * outputs, meaning previous outputs can be rewritten or modified as new outputs
+ * are added. It is therefore intended for use on a user's local machines.
+ *
+ * In CI environments the static equivalent of this life cycle should be used.
+ *
+ * NOTE: output.dim() should be preferred over output.colors.gray() because it
+ * is much more consistently readable across different terminal color themes.
+ */
+export declare function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, args, overrides, }: {
+    initiatingProject: string;
+    tasks: Task[];
+    args: {
+        configuration?: string;
+        parallel?: number;
+    };
+    overrides: Record<string, unknown>;
+}): Promise<{
+    lifeCycle: LifeCycle;
+    renderIsDone: Promise<void>;
+}>;

package/src/tasks-runner/life-cycles/dynamic-run-one-terminal-output-life-cycle.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRunOneDynamicOutputRenderer = void 0;
+const cliCursor = require("cli-cursor");
+const cli_spinners_1 = require("cli-spinners");
+const os_1 = require("os");
+const readline = require("readline");
+const output_1 = require("../../utils/output");
+const pretty_time_1 = require("./pretty-time");
+const formatting_utils_1 = require("./formatting-utils");
+const view_logs_utils_1 = require("./view-logs-utils");
+/**
+ * The following function is responsible for creating a life cycle with dynamic
+ * outputs, meaning previous outputs can be rewritten or modified as new outputs
+ * are added. It is therefore intended for use on a user's local machines.
+ *
+ * In CI environments the static equivalent of this life cycle should be used.
+ *
+ * NOTE: output.dim() should be preferred over output.colors.gray() because it
+ * is much more consistently readable across different terminal color themes.
+ */
+async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, args, overrides, }) {
+    cliCursor.hide();
+    let resolveRenderIsDonePromise;
+    const renderIsDone = new Promise((resolve) => (resolveRenderIsDonePromise = resolve)).then(() => {
+        clearRenderInterval();
+        cliCursor.show();
+    });
+    function clearRenderInterval() {
+        if (renderDependentTargetsIntervalId) {
+            clearInterval(renderDependentTargetsIntervalId);
+        }
+    }
+    process.on('exit', () => clearRenderInterval());
+    process.on('SIGINT', () => clearRenderInterval());
+    process.on('SIGTERM', () => clearRenderInterval());
+    process.on('SIGHUP', () => clearRenderInterval());
+    const lifeCycle = {};
+    const start = process.hrtime();
+    const figures = await Promise.resolve().then(() => require('figures'));
+    let state = 'EXECUTING_DEPENDENT_TARGETS';
+    const tasksToTerminalOutputs = {};
+    const totalTasks = tasks.length;
+    const totalDependentTasks = totalTasks - 1;
+    const totalTasksFromInitiatingProject = tasks.filter((t) => t.target.project === initiatingProject).length;
+    // Tasks from the initiating project are treated differently, they forward their output
+    const totalDependentTasksNotFromInitiatingProject = totalTasks - totalTasksFromInitiatingProject;
+    const targetName = tasks[0].target.target;
+    let dependentTargetsNumLines = 0;
+    let totalCompletedTasks = 0;
+    let totalSuccessfulTasks = 0;
+    let totalFailedTasks = 0;
+    let totalCachedTasks = 0;
+    // Used to control the rendering of the spinner
+    let dependentTargetsCurrentFrame = 0;
+    let renderDependentTargetsIntervalId;
+    const moveCursorToStartOfDependentTargetLines = () => {
+        readline.moveCursor(process.stdout, 0, -dependentTargetsNumLines);
+    };
+    const renderLines = (lines, dividerColor = 'cyan', renderDivider = true, skipPadding = false) => {
+        let additionalLines = 0;
+        if (renderDivider) {
+            const dividerLines = output_1.output.getVerticalSeparatorLines(dividerColor);
+            for (const line of dividerLines) {
+                output_1.output.overwriteLine(line);
+            }
+            additionalLines += dividerLines.length;
+            lines.push('');
+        }
+        for (const line of lines) {
+            output_1.output.overwriteLine((skipPadding ? '' : output_1.output.X_PADDING) + line);
+        }
+        dependentTargetsNumLines = lines.length + additionalLines;
+        // clear any possible text below the cursor's position
+        readline.clearScreenDown(process.stdout);
+    };
+    const renderDependentTargets = (renderDivider = true) => {
+        if (totalDependentTasksNotFromInitiatingProject <= 0) {
+            return;
+        }
+        const max = cli_spinners_1.dots.frames.length - 1;
+        const curr = dependentTargetsCurrentFrame;
+        dependentTargetsCurrentFrame = curr >= max ? 0 : curr + 1;
+        const linesToRender = [''];
+        const remainingDependentTasksNotFromInitiatingProject = totalDependentTasksNotFromInitiatingProject - totalCompletedTasks;
+        switch (state) {
+            case 'EXECUTING_DEPENDENT_TARGETS':
+                if (totalFailedTasks === 0) {
+                    linesToRender.push(`   ${output_1.output.colors.cyan(cli_spinners_1.dots.frames[dependentTargetsCurrentFrame])}    ${output_1.output.dim(`Nx is waiting on ${remainingDependentTasksNotFromInitiatingProject} dependent project tasks before running tasks from`)} ${initiatingProject}${output_1.output.dim('...')}`);
+                    if (totalSuccessfulTasks > 0) {
+                        linesToRender.push('');
+                    }
+                }
+                break;
+        }
+        if (totalFailedTasks > 0) {
+            linesToRender.push(output_1.output.colors.red.dim(`   ${output_1.output.colors.red(figures.cross)}    ${totalFailedTasks}${`/${totalCompletedTasks}`} dependent project tasks failed (see below)`));
+        }
+        if (totalSuccessfulTasks > 0) {
+            linesToRender.push(output_1.output.dim(`   ${output_1.output.dim(figures.tick)}    ${totalSuccessfulTasks}${`/${totalCompletedTasks}`} dependent project tasks succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`));
+        }
+        moveCursorToStartOfDependentTargetLines();
+        if (linesToRender.length > 1) {
+            renderLines(linesToRender, 'gray', renderDivider && state !== 'EXECUTING_DEPENDENT_TARGETS', true);
+        }
+        else {
+            renderLines([]);
+        }
+    };
+    lifeCycle.startCommand = () => {
+        renderDependentTargets();
+    };
+    lifeCycle.startTasks = (tasks) => {
+        for (const task of tasks) {
+            // Move from the dependent project tasks phase to the initiating project's targets
+            if (task.target.project === initiatingProject &&
+                state !== 'EXECUTING_INITIATING_PROJECT_TARGET') {
+                state = 'EXECUTING_INITIATING_PROJECT_TARGET';
+                clearRenderInterval();
+                renderDependentTargets(false);
+                if (totalDependentTasksNotFromInitiatingProject > 0) {
+                    output_1.output.addNewline();
+                    process.stdout.write(`   ${output_1.output.dim('Hint: you can run the command with')} --verbose ${output_1.output.dim('to see the full dependent project outputs')}` + os_1.EOL);
+                    output_1.output.addVerticalSeparator('gray');
+                }
+            }
+        }
+        if (!renderDependentTargetsIntervalId &&
+            state === 'EXECUTING_DEPENDENT_TARGETS') {
+            renderDependentTargetsIntervalId = setInterval(renderDependentTargets, 100);
+        }
+    };
+    lifeCycle.printTaskTerminalOutput = (task, cacheStatus, terminalOutput) => {
+        if (task.target.project === initiatingProject) {
+            output_1.output.logCommandOutput(task.id, cacheStatus, terminalOutput);
+        }
+        else {
+            tasksToTerminalOutputs[task.id] = terminalOutput;
+        }
+    };
+    lifeCycle.endTasks = (taskResults) => {
+        for (let t of taskResults) {
+            totalCompletedTasks++;
+            switch (t.status) {
+                case 'remote-cache':
+                case 'local-cache':
+                case 'local-cache-kept-existing':
+                    totalCachedTasks++;
+                    totalSuccessfulTasks++;
+                    break;
+                case 'success':
+                    totalSuccessfulTasks++;
+                    break;
+                case 'failure':
+                    totalFailedTasks++;
+                    /**
+                     * A dependent project has failed so we stop executing and update the relevant
+                     * dependent project task messaging
+                     */
+                    if (t.task.target.project !== initiatingProject) {
+                        clearRenderInterval();
+                        renderDependentTargets(false);
+                        output_1.output.addVerticalSeparator('red');
+                        output_1.output.logCommandOutput(t.task.id, t.status, tasksToTerminalOutputs[t.task.id]);
+                    }
+                    break;
+            }
+            delete tasksToTerminalOutputs[t.task.id];
+        }
+    };
+    lifeCycle.endCommand = () => {
+        clearRenderInterval();
+        const timeTakenText = (0, pretty_time_1.prettyTime)(process.hrtime(start));
+        if (totalSuccessfulTasks === totalTasks) {
+            state = 'COMPLETED_SUCCESSFULLY';
+            const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)([initiatingProject], [targetName], tasks)}`;
+            const taskOverridesLines = [];
+            if (Object.keys(overrides).length > 0) {
+                const leftPadding = `${output_1.output.X_PADDING}       `;
+                taskOverridesLines.push('');
+                taskOverridesLines.push(`${leftPadding}${output_1.output.dim.green('With additional flags:')}`);
+                Object.entries(overrides)
+                    .map(([flag, value]) => output_1.output.dim.green((0, formatting_utils_1.formatFlags)(leftPadding, flag, value)))
+                    .forEach((arg) => taskOverridesLines.push(arg));
+            }
+            const pinnedFooterLines = [
+                output_1.output.applyNxPrefix('green', output_1.output.colors.green(text) + output_1.output.dim(` (${timeTakenText})`)),
+                ...taskOverridesLines,
+            ];
+            if (totalCachedTasks > 0) {
+                pinnedFooterLines.push(output_1.output.dim(`${os_1.EOL}   Nx read the output from the cache instead of running the command for ${totalCachedTasks} out of ${totalTasks} tasks.`));
+            }
+            renderLines(pinnedFooterLines, 'green');
+        }
+        else {
+            state = 'COMPLETED_WITH_ERRORS';
+            let text = `Ran target ${output_1.output.bold(targetName)} for project ${output_1.output.bold(initiatingProject)}`;
+            if (totalDependentTasks > 0) {
+                text += ` and ${output_1.output.bold(totalDependentTasks)} task(s) they depend on`;
+            }
+            const taskOverridesLines = [];
+            if (Object.keys(overrides).length > 0) {
+                const leftPadding = `${output_1.output.X_PADDING}       `;
+                taskOverridesLines.push('');
+                taskOverridesLines.push(`${leftPadding}${output_1.output.dim.red('With additional flags:')}`);
+                Object.entries(overrides)
+                    .map(([flag, value]) => output_1.output.dim.red((0, formatting_utils_1.formatFlags)(leftPadding, flag, value)))
+                    .forEach((arg) => taskOverridesLines.push(arg));
+            }
+            const viewLogs = (0, view_logs_utils_1.viewLogsFooterRows)(totalFailedTasks);
+            renderLines([
+                output_1.output.applyNxPrefix('red', output_1.output.colors.red(text) + output_1.output.dim(` (${timeTakenText})`)),
+                ...taskOverridesLines,
+                '',
+                `   ${output_1.output.colors.red(figures.cross)}    ${totalFailedTasks}${`/${totalCompletedTasks}`} failed`,
+                `   ${output_1.output.dim(figures.tick)}    ${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`,
+                ...viewLogs,
+            ], 'red');
+        }
+        resolveRenderIsDonePromise();
+    };
+    return { lifeCycle, renderIsDone };
+}
+exports.createRunOneDynamicOutputRenderer = createRunOneDynamicOutputRenderer;

package/src/tasks-runner/life-cycles/empty-terminal-output-life-cycle.d.ts

@@ -0,0 +1,5 @@
+import type { LifeCycle } from '../life-cycle';
+import { TaskStatus } from '../tasks-runner';
+export declare class EmptyTerminalOutputLifeCycle implements LifeCycle {
+    printTaskTerminalOutput(task: any, cacheStatus: TaskStatus, terminalOutput: string): void;
+}

package/src/tasks-runner/life-cycles/empty-terminal-output-life-cycle.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptyTerminalOutputLifeCycle = void 0;
+const output_1 = require("../../utils/output");
+const utils_1 = require("../utils");
+class EmptyTerminalOutputLifeCycle {
+    printTaskTerminalOutput(task, cacheStatus, terminalOutput) {
+        if (cacheStatus === 'success' ||
+            cacheStatus === 'failure' ||
+            cacheStatus === 'skipped') {
+            const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+            output_1.output.logCommandOutput(args.join(' '), cacheStatus, terminalOutput);
+        }
+    }
+}
+exports.EmptyTerminalOutputLifeCycle = EmptyTerminalOutputLifeCycle;

package/src/tasks-runner/life-cycles/formatting-utils.d.ts

@@ -0,0 +1,3 @@
+import { Task } from '../../config/task-graph';
+export declare function formatFlags(leftPadding: string, flag: string, value: any): string;
+export declare function formatTargetsAndProjects(projectNames: string[], targets: string[], tasks: Task[]): any;

package/src/tasks-runner/life-cycles/formatting-utils.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTargetsAndProjects = exports.formatFlags = void 0;
+const output_1 = require("../../utils/output");
+function formatFlags(leftPadding, flag, value) {
+    return flag == '_'
+        ? `${leftPadding}  ${value.join(' ')}`
+        : `${leftPadding}  --${flag}=${formatValue(value)}`;
+}
+exports.formatFlags = formatFlags;
+function formatValue(value) {
+    if (Array.isArray(value)) {
+        return `[${value.join(',')}]`;
+    }
+    else if (typeof value === 'object') {
+        return JSON.stringify(value);
+    }
+    else {
+        return value;
+    }
+}
+function formatTargetsAndProjects(projectNames, targets, tasks) {
+    if (tasks.length === 1)
+        return `target ${targets[0]} for project ${projectNames[0]}`;
+    let text;
+    const project = projectNames.length === 1
+        ? `project ${projectNames[0]}`
+        : `${projectNames.length} projects`;
+    if (targets.length === 1) {
+        text = `target ${output_1.output.bold(targets[0])} for ${project}`;
+    }
+    else {
+        text = `targets ${targets
+            .map((t) => output_1.output.bold(t))
+            .join(', ')} for ${project}`;
+    }
+    const dependentTasks = tasks.filter((t) => projectNames.indexOf(t.target.project) === -1 ||
+        targets.indexOf(t.target.target) === -1).length;
+    if (dependentTasks > 0) {
+        text += ` and ${output_1.output.bold(dependentTasks)} ${dependentTasks === 1 ? 'task' : 'tasks'} ${projectNames.length === 1 ? 'it depends on' : 'they depend on'}`;
+    }
+    return text;
+}
+exports.formatTargetsAndProjects = formatTargetsAndProjects;