@ohos-ports/nx 19.8.4-beta.0

package/src/utils/json.d.ts

@@ -0,0 +1,44 @@
+import { stripComments } from 'jsonc-parser';
+import type { ParseOptions } from 'jsonc-parser';
+export { stripComments as stripJsonComments };
+export interface JsonParseOptions extends ParseOptions {
+    /**
+     * Expect JSON with javascript-style
+     * @default false
+     */
+    expectComments?: boolean;
+    /**
+     * Disallow javascript-style
+     * @default false
+     */
+    disallowComments?: boolean;
+    /**
+     * Allow trailing commas in the JSON content
+     */
+    allowTrailingComma?: boolean;
+}
+export interface JsonSerializeOptions {
+    /**
+     * the whitespaces to add as indentation to make the output more readable.
+     * @default 2
+     */
+    spaces?: number;
+}
+/**
+ * Parses the given JSON string and returns the object the JSON content represents.
+ * By default javascript-style comments and trailing commas are allowed.
+ *
+ * @param input JSON content as string
+ * @param options JSON parse options
+ * @returns Object the JSON content represents
+ */
+export declare function parseJson<T extends object = any>(input: string, options?: JsonParseOptions): T;
+/**
+ * Serializes the given data to a JSON string.
+ * By default the JSON string is formatted with a 2 space indentation to be easy readable.
+ *
+ * @param input Object which should be serialized to JSON
+ * @param options JSON serialize options
+ * @returns the formatted JSON representation of the object
+ */
+export declare function serializeJson<T extends object = object>(input: T, options?: JsonSerializeOptions): string;

package/src/utils/json.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripJsonComments = void 0;
+exports.parseJson = parseJson;
+exports.serializeJson = serializeJson;
+const jsonc_parser_1 = require("jsonc-parser");
+Object.defineProperty(exports, "stripJsonComments", { enumerable: true, get: function () { return jsonc_parser_1.stripComments; } });
+const lines_and_columns_1 = require("lines-and-columns");
+const code_frames_1 = require("./code-frames");
+/**
+ * Parses the given JSON string and returns the object the JSON content represents.
+ * By default javascript-style comments and trailing commas are allowed.
+ *
+ * @param input JSON content as string
+ * @param options JSON parse options
+ * @returns Object the JSON content represents
+ */
+function parseJson(input, options) {
+    try {
+        if (options?.expectComments !== true) {
+            return JSON.parse(input);
+        }
+    }
+    catch { }
+    options = { allowTrailingComma: true, ...options };
+    const errors = [];
+    const result = (0, jsonc_parser_1.parse)(input, errors, options);
+    if (errors.length > 0) {
+        throw new Error(formatParseError(input, errors[0]));
+    }
+    return result;
+}
+/**
+ * Nicely formats a JSON error with context
+ *
+ * @param input JSON content as string
+ * @param parseError jsonc ParseError
+ * @returns
+ */
+function formatParseError(input, parseError) {
+    const { error, offset, length } = parseError;
+    let { line, column } = new lines_and_columns_1.LinesAndColumns(input).locationForIndex(offset);
+    line++;
+    column++;
+    return (`${(0, jsonc_parser_1.printParseErrorCode)(error)} in JSON at ${line}:${column}\n` +
+        (0, code_frames_1.codeFrameColumns)(input, {
+            start: { line, column },
+            end: { line, column: column + length },
+        }) +
+        '\n');
+}
+/**
+ * Serializes the given data to a JSON string.
+ * By default the JSON string is formatted with a 2 space indentation to be easy readable.
+ *
+ * @param input Object which should be serialized to JSON
+ * @param options JSON serialize options
+ * @returns the formatted JSON representation of the object
+ */
+function serializeJson(input, options) {
+    return JSON.stringify(input, null, options?.spaces ?? 2);
+}

package/src/utils/legacy-task-history.d.ts

@@ -0,0 +1,8 @@
+declare const taskRunKeys: readonly ["project", "target", "configuration", "hash", "code", "status", "start", "end"];
+export type TaskRun = Record<(typeof taskRunKeys)[number], string>;
+export declare function getHistoryForHashes(hashes: string[]): Promise<{
+    [hash: string]: TaskRun[];
+}>;
+export declare function writeTaskRunsToHistory(taskRuns: TaskRun[]): Promise<void>;
+export declare const taskHistoryFile: string;
+export {};

package/src/utils/legacy-task-history.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskHistoryFile = void 0;
+exports.getHistoryForHashes = getHistoryForHashes;
+exports.writeTaskRunsToHistory = writeTaskRunsToHistory;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const cache_directory_1 = require("./cache-directory");
+const taskRunKeys = [
+    'project',
+    'target',
+    'configuration',
+    'hash',
+    'code',
+    'status',
+    'start',
+    'end',
+];
+let taskHistory = undefined;
+let taskHashToIndicesMap = new Map();
+async function getHistoryForHashes(hashes) {
+    if (taskHistory === undefined) {
+        loadTaskHistoryFromDisk();
+    }
+    const result = {};
+    for (let hash of hashes) {
+        const indices = taskHashToIndicesMap.get(hash);
+        if (!indices) {
+            result[hash] = [];
+        }
+        else {
+            result[hash] = indices.map((index) => taskHistory[index]);
+        }
+    }
+    return result;
+}
+async function writeTaskRunsToHistory(taskRuns) {
+    if (taskHistory === undefined) {
+        loadTaskHistoryFromDisk();
+    }
+    const serializedLines = [];
+    for (let taskRun of taskRuns) {
+        const serializedLine = taskRunKeys.map((key) => taskRun[key]).join(',');
+        serializedLines.push(serializedLine);
+        recordTaskRunInMemory(taskRun);
+    }
+    if (!(0, fs_1.existsSync)(exports.taskHistoryFile)) {
+        (0, fs_1.writeFileSync)(exports.taskHistoryFile, `${taskRunKeys.join(',')}\n`);
+    }
+    (0, fs_1.appendFileSync)(exports.taskHistoryFile, serializedLines.join('\n') + '\n');
+}
+exports.taskHistoryFile = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'task-history.csv');
+function loadTaskHistoryFromDisk() {
+    taskHashToIndicesMap.clear();
+    taskHistory = [];
+    if (!(0, fs_1.existsSync)(exports.taskHistoryFile)) {
+        return;
+    }
+    const fileContent = (0, fs_1.readFileSync)(exports.taskHistoryFile, 'utf8');
+    if (!fileContent) {
+        return;
+    }
+    const lines = fileContent.split('\n');
+    // if there are no lines or just the header, return
+    if (lines.length <= 1) {
+        return;
+    }
+    const contentLines = lines.slice(1).filter((l) => l.trim() !== '');
+    // read the values from csv format where each header is a key and the value is the value
+    for (let line of contentLines) {
+        const values = line.trim().split(',');
+        const run = {};
+        taskRunKeys.forEach((header, index) => {
+            run[header] = values[index];
+        });
+        recordTaskRunInMemory(run);
+    }
+}
+function recordTaskRunInMemory(taskRun) {
+    const index = taskHistory.push(taskRun) - 1;
+    if (taskHashToIndicesMap.has(taskRun.hash)) {
+        taskHashToIndicesMap.get(taskRun.hash).push(index);
+    }
+    else {
+        taskHashToIndicesMap.set(taskRun.hash, [index]);
+    }
+}

package/src/utils/logger.d.ts

@@ -0,0 +1,12 @@
+export declare const NX_PREFIX: string;
+export declare const NX_ERROR: string;
+export declare const logger: {
+    warn: (s: any) => void;
+    error: (s: any) => void;
+    info: (s: any) => void;
+    log: (...s: any[]) => void;
+    debug: (...s: any[]) => void;
+    fatal: (...s: any[]) => void;
+    verbose: (...s: any[]) => void;
+};
+export declare function stripIndent(str: string): string;

package/src/utils/logger.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.NX_ERROR = exports.NX_PREFIX = void 0;
+exports.stripIndent = stripIndent;
+const chalk = require("chalk");
+exports.NX_PREFIX = chalk.inverse(chalk.bold(chalk.cyan(' NX ')));
+exports.NX_ERROR = chalk.inverse(chalk.bold(chalk.red(' ERROR ')));
+exports.logger = {
+    warn: (s) => console.warn(chalk.bold(chalk.yellow(s))),
+    error: (s) => {
+        if (typeof s === 'string' && s.startsWith('NX ')) {
+            console.error(`\n${exports.NX_ERROR} ${chalk.bold(chalk.red(s.slice(3)))}\n`);
+        }
+        else if (s instanceof Error && s.stack) {
+            console.error(chalk.bold(chalk.red(s.stack)));
+        }
+        else {
+            console.error(chalk.bold(chalk.red(s)));
+        }
+    },
+    info: (s) => {
+        if (typeof s === 'string' && s.startsWith('NX ')) {
+            console.info(`\n${exports.NX_PREFIX} ${chalk.bold(s.slice(3))}\n`);
+        }
+        else {
+            console.info(s);
+        }
+    },
+    log: (...s) => {
+        console.log(...s);
+    },
+    debug: (...s) => {
+        console.debug(...s);
+    },
+    fatal: (...s) => {
+        console.error(...s);
+    },
+    verbose: (...s) => {
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            console.log(...s);
+        }
+    },
+};
+function stripIndent(str) {
+    const match = str.match(/^[ \t]*(?=\S)/gm);
+    if (!match) {
+        return str;
+    }
+    const indent = match.reduce((r, a) => Math.min(r, a.length), Infinity);
+    const regex = new RegExp(`^[ \\t]{${indent}}`, 'gm');
+    return str.replace(regex, '');
+}

package/src/utils/nx-cloud-utils.d.ts

@@ -0,0 +1,3 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+export declare function isNxCloudUsed(nxJson: NxJsonConfiguration): boolean;
+export declare function getNxCloudUrl(nxJson: NxJsonConfiguration): string;

package/src/utils/nx-cloud-utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNxCloudUsed = isNxCloudUsed;
+exports.getNxCloudUrl = getNxCloudUrl;
+function isNxCloudUsed(nxJson) {
+    return (!!process.env.NX_CLOUD_ACCESS_TOKEN ||
+        !!nxJson.nxCloudAccessToken ||
+        !!nxJson.nxCloudId ||
+        !!Object.values(nxJson.tasksRunnerOptions ?? {}).find((r) => r.runner == '@nrwl/nx-cloud' || r.runner == 'nx-cloud'));
+}
+function getNxCloudUrl(nxJson) {
+    const cloudRunner = Object.values(nxJson.tasksRunnerOptions ?? {}).find((r) => r.runner == '@nrwl/nx-cloud' || r.runner == 'nx-cloud');
+    if (!cloudRunner &&
+        !(nxJson.nxCloudAccessToken || process.env.NX_CLOUD_ACCESS_TOKEN) &&
+        !nxJson.nxCloudId)
+        throw new Error('nx-cloud runner not found in nx.json');
+    return cloudRunner?.options?.url ?? nxJson.nxCloudUrl ?? 'https://nx.app';
+}

package/src/utils/nx-plugin.deprecated.d.ts

@@ -0,0 +1,31 @@
+import { ProjectGraphProcessor } from '../config/project-graph';
+import { TargetConfiguration } from '../config/workspace-json-project-json';
+import { NxPluginV2 } from '../project-graph/plugins';
+/**
+ * @deprecated Add targets to the projects in a {@link CreateNodes} function instead. This will be removed in Nx 20
+ */
+export type ProjectTargetConfigurator = (file: string) => Record<string, TargetConfiguration>;
+/**
+ * @deprecated Use {@link NxPluginV2} instead. This will be removed in Nx 20
+ */
+export type NxPluginV1 = {
+    name: string;
+    /**
+     * @deprecated Use {@link CreateNodes} and {@link CreateDependencies} instead. This will be removed in Nx 20
+     */
+    processProjectGraph?: ProjectGraphProcessor;
+    /**
+     * @deprecated Add targets to the projects inside of {@link CreateNodes} instead. This will be removed in Nx 20
+     */
+    registerProjectTargets?: ProjectTargetConfigurator;
+    /**
+     * A glob pattern to search for non-standard project files.
+     * @example: ["*.csproj", "pom.xml"]
+     * @deprecated Use {@link CreateNodes} instead. This will be removed in Nx 20
+     */
+    projectFilePatterns?: string[];
+};
+/**
+ * @todo(@agentender) v20: Remove this fn when we remove readWorkspaceConfig
+ */
+export declare function getDefaultPluginsSync(root: string): NxPluginV2[];

package/src/utils/nx-plugin.deprecated.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultPluginsSync = getDefaultPluginsSync;
+const angular_json_1 = require("../adapter/angular-json");
+const project_json_1 = require("../plugins/project-json/build-nodes/project-json");
+const PackageJsonWorkspacesPlugin = require("../plugins/package-json");
+/**
+ * @todo(@agentender) v20: Remove this fn when we remove readWorkspaceConfig
+ */
+function getDefaultPluginsSync(root) {
+    const plugins = [
+        require('../plugins/js'),
+        ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
+            ? [require('../adapter/angular-json').NxAngularJsonPlugin]
+            : []),
+        PackageJsonWorkspacesPlugin,
+        project_json_1.default,
+    ];
+    return plugins;
+}

package/src/utils/object-sort.d.ts

@@ -0,0 +1 @@
+export declare function sortObjectByKeys(originalObject: object): {};

package/src/utils/object-sort.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortObjectByKeys = sortObjectByKeys;
+function sortObjectByKeys(originalObject) {
+    const keys = Object.keys(originalObject).sort();
+    const sortedObject = {};
+    keys.forEach((key) => (sortedObject[key] = originalObject[key]));
+    return sortedObject;
+}

package/src/utils/output.d.ts

@@ -0,0 +1,71 @@
+import * as chalk from 'chalk';
+import type { TaskStatus } from '../tasks-runner/tasks-runner';
+export interface CLIErrorMessageConfig {
+    title: string;
+    bodyLines?: string[];
+    slug?: string;
+}
+export interface CLIWarnMessageConfig {
+    title: string;
+    bodyLines?: string[];
+    slug?: string;
+}
+export interface CLINoteMessageConfig {
+    title: string;
+    bodyLines?: string[];
+}
+export interface CLISuccessMessageConfig {
+    title: string;
+    bodyLines?: string[];
+}
+declare class CLIOutput {
+    cliName: string;
+    formatCommand: (taskId: string) => string;
+    /**
+     * Longer dash character which forms more of a continuous line when place side to side
+     * with itself, unlike the standard dash character
+     */
+    private get VERTICAL_SEPARATOR();
+    /**
+     * Expose some color and other utility functions so that other parts of the codebase that need
+     * more fine-grained control of message bodies are still using a centralized
+     * implementation.
+     */
+    colors: {
+        gray: chalk.Chalk;
+        green: chalk.Chalk;
+        red: chalk.Chalk;
+        cyan: chalk.Chalk;
+        white: chalk.Chalk;
+    };
+    bold: chalk.Chalk;
+    underline: chalk.Chalk;
+    dim: chalk.Chalk;
+    private writeToStdOut;
+    overwriteLine(lineText?: string): void;
+    private writeOutputTitle;
+    private writeOptionalOutputBody;
+    applyNxPrefix(color: string, text: string): string;
+    addNewline(): void;
+    addVerticalSeparator(color?: string): void;
+    addVerticalSeparatorWithoutNewLines(color?: string): void;
+    getVerticalSeparatorLines(color?: string): string[];
+    private getVerticalSeparator;
+    error({ title, slug, bodyLines }: CLIErrorMessageConfig): void;
+    warn({ title, slug, bodyLines }: CLIWarnMessageConfig): void;
+    note({ title, bodyLines }: CLINoteMessageConfig): void;
+    success({ title, bodyLines }: CLISuccessMessageConfig): void;
+    logSingleLine(message: string): void;
+    logCommand(message: string, taskStatus?: TaskStatus): void;
+    logCommandOutput(message: string, taskStatus: TaskStatus, output: string): void;
+    private getCommandWithStatus;
+    private getStatusIcon;
+    private normalizeMessage;
+    private addTaskStatus;
+    log({ title, bodyLines, color }: CLIWarnMessageConfig & {
+        color?: string;
+    }): void;
+    drain(): Promise<void>;
+}
+export declare const output: CLIOutput;
+export {};

package/src/utils/output.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.output = void 0;
+const chalk = require("chalk");
+const os_1 = require("os");
+const readline = require("readline");
+const is_ci_1 = require("./is-ci");
+const GH_GROUP_PREFIX = '::group::';
+const GH_GROUP_SUFFIX = '::endgroup::';
+/**
+ * Automatically disable styling applied by chalk if CI=true
+ */
+const forceColor = process.env.FORCE_COLOR === '' || process.env.FORCE_COLOR === 'true';
+if ((0, is_ci_1.isCI)() && !forceColor) {
+    chalk.level = 0;
+}
+class CLIOutput {
+    constructor() {
+        this.cliName = 'NX';
+        this.formatCommand = (taskId) => `${chalk.dim('nx run')} ${taskId}`;
+        /**
+         * Expose some color and other utility functions so that other parts of the codebase that need
+         * more fine-grained control of message bodies are still using a centralized
+         * implementation.
+         */
+        this.colors = {
+            gray: chalk.gray,
+            green: chalk.green,
+            red: chalk.red,
+            cyan: chalk.cyan,
+            white: chalk.white,
+        };
+        this.bold = chalk.bold;
+        this.underline = chalk.underline;
+        this.dim = chalk.dim;
+    }
+    /**
+     * Longer dash character which forms more of a continuous line when place side to side
+     * with itself, unlike the standard dash character
+     */
+    get VERTICAL_SEPARATOR() {
+        let divider = '';
+        for (let i = 0; i < process.stdout.columns - 1; i++) {
+            divider += '\u2014';
+        }
+        return divider;
+    }
+    writeToStdOut(str) {
+        process.stdout.write(str);
+    }
+    overwriteLine(lineText = '') {
+        // this replaces the existing text up to the new line length
+        process.stdout.write(lineText);
+        // clear whatever text might be left to the right of the cursor (happens
+        // when existing text was longer than new one)
+        readline.clearLine(process.stdout, 1);
+        process.stdout.write(os_1.EOL);
+    }
+    writeOutputTitle({ color, title, }) {
+        this.writeToStdOut(`${this.applyNxPrefix(color, title)}${os_1.EOL}`);
+    }
+    writeOptionalOutputBody(bodyLines) {
+        if (!bodyLines) {
+            return;
+        }
+        this.addNewline();
+        bodyLines.forEach((bodyLine) => this.writeToStdOut(`${bodyLine}${os_1.EOL}`));
+    }
+    applyNxPrefix(color = 'cyan', text) {
+        let nxPrefix = '';
+        if (chalk[color]) {
+            nxPrefix = chalk.reset.inverse.bold[color](` ${this.cliName} `);
+        }
+        else {
+            nxPrefix = chalk.reset.inverse.bold.keyword(color)(` ${this.cliName} `);
+        }
+        return `${nxPrefix}  ${text}`;
+    }
+    addNewline() {
+        this.writeToStdOut(os_1.EOL);
+    }
+    addVerticalSeparator(color = 'gray') {
+        this.addNewline();
+        this.addVerticalSeparatorWithoutNewLines(color);
+        this.addNewline();
+    }
+    addVerticalSeparatorWithoutNewLines(color = 'gray') {
+        this.writeToStdOut(`${this.getVerticalSeparator(color)}${os_1.EOL}`);
+    }
+    getVerticalSeparatorLines(color = 'gray') {
+        return ['', this.getVerticalSeparator(color), ''];
+    }
+    getVerticalSeparator(color) {
+        return chalk.dim[color](this.VERTICAL_SEPARATOR);
+    }
+    error({ title, slug, bodyLines }) {
+        this.addNewline();
+        this.writeOutputTitle({
+            color: 'red',
+            title: chalk.red(title),
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        /**
+         * Optional slug to be used in an Nx error message redirect URL
+         */
+        if (slug && typeof slug === 'string') {
+            this.addNewline();
+            this.writeToStdOut(`${chalk.grey('  Learn more about this error: ')}https://errors.nx.dev/${slug}${os_1.EOL}`);
+        }
+        this.addNewline();
+    }
+    warn({ title, slug, bodyLines }) {
+        this.addNewline();
+        this.writeOutputTitle({
+            color: 'yellow',
+            title: chalk.yellow(title),
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        /**
+         * Optional slug to be used in an Nx warning message redirect URL
+         */
+        if (slug && typeof slug === 'string') {
+            this.addNewline();
+            this.writeToStdOut(`${chalk.grey('  Learn more about this warning: ')}https://errors.nx.dev/${slug}${os_1.EOL}`);
+        }
+        this.addNewline();
+    }
+    note({ title, bodyLines }) {
+        this.addNewline();
+        this.writeOutputTitle({
+            color: 'orange',
+            title: chalk.keyword('orange')(title),
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        this.addNewline();
+    }
+    success({ title, bodyLines }) {
+        this.addNewline();
+        this.writeOutputTitle({
+            color: 'green',
+            title: chalk.green(title),
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        this.addNewline();
+    }
+    logSingleLine(message) {
+        this.addNewline();
+        this.writeOutputTitle({
+            color: 'gray',
+            title: message,
+        });
+        this.addNewline();
+    }
+    logCommand(message, taskStatus) {
+        this.addNewline();
+        this.writeToStdOut(this.getCommandWithStatus(message, taskStatus));
+        this.addNewline();
+        this.addNewline();
+    }
+    logCommandOutput(message, taskStatus, output) {
+        let commandOutputWithStatus = this.getCommandWithStatus(message, taskStatus);
+        if (process.env.NX_SKIP_LOG_GROUPING !== 'true' &&
+            process.env.GITHUB_ACTIONS) {
+            const icon = this.getStatusIcon(taskStatus);
+            commandOutputWithStatus = `${GH_GROUP_PREFIX}${icon} ${commandOutputWithStatus}`;
+        }
+        this.addNewline();
+        this.writeToStdOut(commandOutputWithStatus);
+        this.addNewline();
+        this.addNewline();
+        this.writeToStdOut(output);
+        if (process.env.NX_SKIP_LOG_GROUPING !== 'true' &&
+            process.env.GITHUB_ACTIONS) {
+            this.writeToStdOut(GH_GROUP_SUFFIX);
+        }
+    }
+    getCommandWithStatus(message, taskStatus) {
+        const commandOutput = chalk.dim('> ') + this.formatCommand(this.normalizeMessage(message));
+        return this.addTaskStatus(taskStatus, commandOutput);
+    }
+    getStatusIcon(taskStatus) {
+        switch (taskStatus) {
+            case 'success':
+                return '✅';
+            case 'failure':
+                return '❌';
+            case 'skipped':
+            case 'local-cache-kept-existing':
+                return '⏩';
+            case 'local-cache':
+            case 'remote-cache':
+                return '🔁';
+        }
+    }
+    normalizeMessage(message) {
+        if (message.startsWith('nx run ')) {
+            return message.substring('nx run '.length);
+        }
+        else if (message.startsWith('run ')) {
+            return message.substring('run '.length);
+        }
+        else {
+            return message;
+        }
+    }
+    addTaskStatus(taskStatus, commandOutput) {
+        if (taskStatus === 'local-cache') {
+            return `${commandOutput}  ${chalk.dim('[local cache]')}`;
+        }
+        else if (taskStatus === 'remote-cache') {
+            return `${commandOutput}  ${chalk.dim('[remote cache]')}`;
+        }
+        else if (taskStatus === 'local-cache-kept-existing') {
+            return `${commandOutput}  ${chalk.dim('[existing outputs match the cache, left as is]')}`;
+        }
+        else {
+            return commandOutput;
+        }
+    }
+    log({ title, bodyLines, color }) {
+        this.addNewline();
+        this.writeOutputTitle({
+            color: 'cyan',
+            title: color ? chalk[color](title) : title,
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        this.addNewline();
+    }
+    drain() {
+        return new Promise((resolve) => {
+            if (process.stdout.writableNeedDrain) {
+                process.stdout.once('drain', resolve);
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+}
+exports.output = new CLIOutput();