@ohos-ports/nx 23.2.0-beta.0 → 23.2.1-beta.0

package/dist/src/tasks-runner/life-cycle.d.ts

@@ -1,86 +0,0 @@
-import { Task } from '../config/task-graph';
-import { BatchInfo, BatchStatus, ExternalObject, PerformanceSummaryPayload, TaskResult, TaskStatus as NativeTaskStatus } from '../native';
-import { TaskStatus } from './tasks-runner';
-/**
- * The result of a completed {@link Task}.
- *
- * Defined as a Rust struct in `packages/nx/src/native/tasks/types.rs` and
- * exposed to TypeScript via NAPI. Re-exported here so existing imports
- * keep working.
- *
- * Task timing information (start and end timestamps) is available
- * on the {@link Task} object itself via {@link Task.startTime} and
- * {@link Task.endTime}.
- */
-export type { TaskResult };
-/**
- * A map of {@link TaskResult} keyed by the ID of the completed {@link Task}s
- */
-export type TaskResults = Record<string, TaskResult>;
-export interface TaskMetadata {
-    groupId: number;
-}
-export interface LifeCycle {
-    /**
-     * @param threadCount total thread-pool size (drives the TUI display)
-     * @param parallel resolved `--parallel` (discrete slots), for the performance report
-     */
-    startCommand?(threadCount?: number, parallel?: number): void | Promise<void>;
-    /** @param summary performance report payload for the TUI exit popup (TUI runs only) */
-    endCommand?(summary?: PerformanceSummaryPayload): void | Promise<void>;
-    scheduleTask?(task: Task): void | Promise<void>;
-    /**
-     * @deprecated use startTasks
-     *
-     * startTask won't be supported after Nx 14 is released.
-     */
-    startTask?(task: Task): void;
-    /**
-     * @deprecated use endTasks
-     *
-     * endTask won't be supported after Nx 14 is released.
-     */
-    endTask?(task: Task, code: number): void;
-    startTasks?(task: Task[], metadata: TaskMetadata): void | Promise<void>;
-    endTasks?(taskResults: TaskResult[], metadata: TaskMetadata): void | Promise<void>;
-    printTaskTerminalOutput?(task: Task, status: TaskStatus, output: string): void;
-    registerRunningTask?(taskId: string, ptyHandles: ExternalObject<[any, any, any]>): void;
-    registerRunningTaskWithEmptyParser?(taskId: string): void;
-    appendTaskOutput?(taskId: string, output: string, isPtyTask: boolean): void;
-    setTaskStatus?(taskId: string, status: NativeTaskStatus): void;
-    setTaskTiming?(taskId: string, startTime: number, endTime: number): void;
-    registerForcedShutdownCallback?(callback: () => void): void;
-    setEstimatedTaskTimings?(timings: Record<string, number>): void;
-    registerRunningBatch?(batchId: string, batchInfo: BatchInfo): void;
-    appendBatchOutput?(batchId: string, output: string): void;
-    setBatchStatus?(batchId: string, status: BatchStatus): void;
-    /**
-     * Set a clickable Nx Cloud link in the terminal UI: `label` is the text
-     * shown, `url` is opened when it's clicked. Implemented by the TUI lifecycle;
-     * callers (e.g. the Nx Cloud client) should feature-detect it.
-     */
-    setCloudLink?(label: string, url: string): void | Promise<void>;
-}
-export declare class CompositeLifeCycle implements LifeCycle {
-    private readonly lifeCycles;
-    constructor(lifeCycles: LifeCycle[]);
-    startCommand(threadCount?: number, parallel?: number): Promise<void>;
-    endCommand(summary?: PerformanceSummaryPayload): Promise<void>;
-    scheduleTask(task: Task): Promise<void>;
-    startTask(task: Task): void;
-    endTask(task: Task, code: number): void;
-    startTasks(tasks: Task[], metadata: TaskMetadata): Promise<void>;
-    endTasks(taskResults: TaskResult[], metadata: TaskMetadata): Promise<void>;
-    printTaskTerminalOutput(task: Task, status: TaskStatus, output: string): void;
-    registerRunningTask(taskId: string, ptyHandles: ExternalObject<[any, any, any]>): void;
-    registerRunningTaskWithEmptyParser(taskId: string): void;
-    appendTaskOutput(taskId: string, output: string, isPtyTask: boolean): void;
-    setTaskStatus(taskId: string, status: NativeTaskStatus): void;
-    setTaskTiming(taskId: string, startTime: number, endTime: number): void;
-    registerForcedShutdownCallback(callback: () => void): void;
-    setEstimatedTaskTimings(timings: Record<string, number>): void;
-    registerRunningBatch(batchId: string, batchInfo: BatchInfo): void;
-    appendBatchOutput(batchId: string, output: string): void;
-    setBatchStatus(batchId: string, status: BatchStatus): void;
-    setCloudLink(label: string, url: string): Promise<void>;
-}

package/dist/src/tasks-runner/life-cycle.js

@@ -1,148 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompositeLifeCycle = void 0;
-class CompositeLifeCycle {
-    constructor(lifeCycles) {
-        this.lifeCycles = lifeCycles;
-    }
-    async startCommand(threadCount, parallel) {
-        for (let l of this.lifeCycles) {
-            if (l.startCommand) {
-                await l.startCommand(threadCount, parallel);
-            }
-        }
-    }
-    async endCommand(summary) {
-        for (let l of this.lifeCycles) {
-            if (l.endCommand) {
-                await l.endCommand(summary);
-            }
-        }
-    }
-    async scheduleTask(task) {
-        for (let l of this.lifeCycles) {
-            if (l.scheduleTask) {
-                await l.scheduleTask(task);
-            }
-        }
-    }
-    startTask(task) {
-        for (let l of this.lifeCycles) {
-            if (l.startTask) {
-                l.startTask(task);
-            }
-        }
-    }
-    endTask(task, code) {
-        for (let l of this.lifeCycles) {
-            if (l.endTask) {
-                l.endTask(task, code);
-            }
-        }
-    }
-    async startTasks(tasks, metadata) {
-        for (let l of this.lifeCycles) {
-            if (l.startTasks) {
-                await l.startTasks(tasks, metadata);
-            }
-            else if (l.startTask) {
-                tasks.forEach((t) => l.startTask(t));
-            }
-        }
-    }
-    async endTasks(taskResults, metadata) {
-        for (let l of this.lifeCycles) {
-            if (l.endTasks) {
-                await l.endTasks(taskResults, metadata);
-            }
-            else if (l.endTask) {
-                taskResults.forEach((t) => l.endTask(t.task, t.code));
-            }
-        }
-    }
-    printTaskTerminalOutput(task, status, output) {
-        for (let l of this.lifeCycles) {
-            if (l.printTaskTerminalOutput) {
-                l.printTaskTerminalOutput(task, status, output);
-            }
-        }
-    }
-    registerRunningTask(taskId, ptyHandles) {
-        for (let l of this.lifeCycles) {
-            if (l.registerRunningTask) {
-                l.registerRunningTask(taskId, ptyHandles);
-            }
-        }
-    }
-    registerRunningTaskWithEmptyParser(taskId) {
-        for (let l of this.lifeCycles) {
-            if (l.registerRunningTaskWithEmptyParser) {
-                l.registerRunningTaskWithEmptyParser(taskId);
-            }
-        }
-    }
-    appendTaskOutput(taskId, output, isPtyTask) {
-        for (let l of this.lifeCycles) {
-            if (l.appendTaskOutput) {
-                l.appendTaskOutput(taskId, output, isPtyTask);
-            }
-        }
-    }
-    setTaskStatus(taskId, status) {
-        for (let l of this.lifeCycles) {
-            if (l.setTaskStatus) {
-                l.setTaskStatus(taskId, status);
-            }
-        }
-    }
-    setTaskTiming(taskId, startTime, endTime) {
-        for (let l of this.lifeCycles) {
-            if (l.setTaskTiming) {
-                l.setTaskTiming(taskId, startTime, endTime);
-            }
-        }
-    }
-    registerForcedShutdownCallback(callback) {
-        for (let l of this.lifeCycles) {
-            if (l.registerForcedShutdownCallback) {
-                l.registerForcedShutdownCallback(callback);
-            }
-        }
-    }
-    setEstimatedTaskTimings(timings) {
-        for (let l of this.lifeCycles) {
-            if (l.setEstimatedTaskTimings) {
-                l.setEstimatedTaskTimings(timings);
-            }
-        }
-    }
-    registerRunningBatch(batchId, batchInfo) {
-        for (let l of this.lifeCycles) {
-            if (l.registerRunningBatch) {
-                l.registerRunningBatch(batchId, batchInfo);
-            }
-        }
-    }
-    appendBatchOutput(batchId, output) {
-        for (let l of this.lifeCycles) {
-            if (l.appendBatchOutput) {
-                l.appendBatchOutput(batchId, output);
-            }
-        }
-    }
-    setBatchStatus(batchId, status) {
-        for (let l of this.lifeCycles) {
-            if (l.setBatchStatus) {
-                l.setBatchStatus(batchId, status);
-            }
-        }
-    }
-    async setCloudLink(label, url) {
-        for (let l of this.lifeCycles) {
-            if (l.setCloudLink) {
-                await l.setCloudLink(label, url);
-            }
-        }
-    }
-}
-exports.CompositeLifeCycle = CompositeLifeCycle;

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

@@ -1,25 +0,0 @@
-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 createRunManyDynamicOutputRenderer({ projectNames, tasks, args, overrides, }: {
-    projectNames: string[];
-    tasks: Task[];
-    args: {
-        targets?: string[];
-        configuration?: string;
-        parallel?: number;
-    };
-    overrides: Record<string, unknown>;
-}): Promise<{
-    lifeCycle: LifeCycle;
-    renderIsDone: Promise<void>;
-}>;

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

@@ -1,366 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRunManyDynamicOutputRenderer = createRunManyDynamicOutputRenderer;
-const tslib_1 = require("tslib");
-const cliCursor = tslib_1.__importStar(require("cli-cursor"));
-const cli_spinners_1 = require("cli-spinners");
-const os_1 = require("os");
-const readline = tslib_1.__importStar(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");
-const handle_import_1 = require("../../utils/handle-import");
-const pc = tslib_1.__importStar(require("picocolors"));
-const LEFT_PAD = `   `;
-const SPACER = `  `;
-const EXTENDED_LEFT_PAD = `      `;
-/**
- * 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();
-    // Show the cursor again after the process exits
-    process.on('exit', () => {
-        cliCursor.show();
-    });
-    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 (0, handle_import_1.handleImport)('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.cursorTo(process.stdout, 0);
-        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(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) +
-                    SPACER +
-                    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) +
-                    SPACER +
-                    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) +
-                    SPACER +
-                    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) +
-                    SPACER +
-                    output_1.output.formatCommand(task.id) +
-                    output_1.output.dim(` (${timeTakenText})`));
-                if (isVerbose) {
-                    writeCommandOutputBlock(tasksToTerminalOutputs[task.id]);
-                }
-                break;
-            }
-            case 'failure':
-                output_1.output.addNewline();
-                output_1.output.addNewline();
-                writeCompletedTaskResultLine(output_1.output.colors.red(figures.cross) +
-                    SPACER +
-                    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(`${LEFT_PAD}${output_1.output.colors.cyan(figures.arrowRight)}${SPACER}Executing ${runningTasks.length}/${remainingTasks} remaining tasks${runningTasks.length > 1 ? ' in parallel' : ''}...`));
-            additionalFooterRows.push('');
-            for (const runningTask of runningTasks) {
-                additionalFooterRows.push(`${LEFT_PAD}${pc.dim(pc.cyan(cli_spinners_1.dots.frames[currentFrame]))}${SPACER}${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(`${LEFT_PAD}${output_1.output.colors.green(figures.tick)}${SPACER}${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`);
-        }
-        if (totalFailedTasks > 0) {
-            additionalFooterRows.push(`${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${totalFailedTasks}${`/${totalCompletedTasks}`} failed`);
-        }
-        moveCursorToStartOfPinnedFooter();
-        if (additionalFooterRows.length > 1) {
-            const text = `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
-            const taskOverridesRows = [];
-            const filteredOverrides = Object.entries(overrides).filter(
-            // Don't print the data passed through from the version subcommand to the publish executor options, it could be quite large and it's an implementation detail.
-            ([flag]) => flag !== 'nxReleaseVersionData');
-            if (filteredOverrides.length > 0) {
-                taskOverridesRows.push('');
-                taskOverridesRows.push(`${EXTENDED_LEFT_PAD}${pc.dim(pc.cyan('With additional flags:'))}`);
-                filteredOverrides
-                    .map(([flag, value]) => pc.dim(pc.cyan((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, 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 (totalTasks === 0) {
-            renderPinnedFooter([output_1.output.applyNxPrefix('gray', 'No tasks were run')]);
-            resolveRenderIsDonePromise();
-            return;
-        }
-        if (totalSuccessfulTasks === totalTasks) {
-            const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
-            const taskOverridesRows = [];
-            const filteredOverrides = Object.entries(overrides).filter(
-            // Don't print the data passed through from the version subcommand to the publish executor options, it could be quite large and it's an implementation detail.
-            ([flag]) => flag !== 'nxReleaseVersionData');
-            if (filteredOverrides.length > 0) {
-                taskOverridesRows.push('');
-                taskOverridesRows.push(`${EXTENDED_LEFT_PAD}${pc.dim(pc.green('With additional flags:'))}`);
-                filteredOverrides
-                    .map(([flag, value]) => pc.dim(pc.green((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, flag, value))))
-                    .forEach((arg) => taskOverridesRows.push(arg));
-            }
-            const pinnedFooterLines = [
-                output_1.output.applyNxPrefix('green', output_1.output.colors.green(text) + pc.dim(pc.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 = [];
-            const filteredOverrides = Object.entries(overrides).filter(
-            // Don't print the data passed through from the version subcommand to the publish executor options, it could be quite large and it's an implementation detail.
-            ([flag]) => flag !== 'nxReleaseVersionData');
-            if (filteredOverrides.length > 0) {
-                taskOverridesRows.push('');
-                taskOverridesRows.push(`${EXTENDED_LEFT_PAD}${pc.dim(pc.red('With additional flags:'))}`);
-                filteredOverrides
-                    .map(([flag, value]) => pc.dim(pc.red((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, 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) + pc.dim(pc.white(` (${timeTakenText})`))),
-                ...taskOverridesRows,
-                '',
-                output_1.output.dim(`${LEFT_PAD}${output_1.output.dim(figures.tick)}${SPACER}${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`),
-                '',
-                `${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${totalFailedTasks}${`/${totalCompletedTasks}`} targets failed, including the following:`,
-                '',
-                `${failedTasksForPrinting
-                    .map((t) => `${EXTENDED_LEFT_PAD}${output_1.output.colors.red('-')} ${output_1.output.formatCommand(t.toString())}`)
-                    .join('\n')}`,
-            ];
-            if (failedTasks.size > numFailedToPrint) {
-                failureSummaryRows.push(output_1.output.dim(`${EXTENDED_LEFT_PAD}...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 };
-}
-function writeCompletedTaskResultLine(line) {
-    output_1.output.overwriteLine(LEFT_PAD + 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 lines = commandOutput.split(/\r?\n/);
-    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(`${EXTENDED_LEFT_PAD}${l}`));
-}

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

@@ -1,24 +0,0 @@
-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>;
-}>;