nx 21.1.0-beta.0 → 21.1.0-beta.2

package/src/daemon/client/client.js

@@ -277,7 +277,7 @@ class DaemonClient {
             type: task_history_1.RECORD_TASK_RUNS,
             taskRuns,
         };
-        return this.sendMessageToDaemon(message);
+        return this.sendToDaemonViaQueue(message);
     }
     getSyncGeneratorChanges(generators) {
         const message = {

package/src/migrations/update-17-0-0/move-cache-directory.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '../../generators/tree';
+export default function moveCacheDirectory(tree: Tree): void;

package/src/migrations/update-17-0-0/move-cache-directory.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = moveCacheDirectory;
+const ignore_1 = require("ignore");
+function moveCacheDirectory(tree) {
+    // If nx.json doesn't exist the repo can't utilize
+    // caching, so .nx/cache is less relevant. Lerna users
+    // that don't want to fully opt in to Nx at this time
+    // may also be caught off guard by the appearance of
+    // a .nx directory, so we are going to special case
+    // this for the time being.
+    if (tree.exists('lerna.json') && !tree.exists('nx.json')) {
+        return;
+    }
+    updateGitIgnore(tree);
+    if (tree.exists('.prettierignore')) {
+        const ignored = tree.read('.prettierignore', 'utf-8');
+        if (!ignored.includes('.nx/cache')) {
+            tree.write('.prettierignore', [ignored, '/.nx/cache'].join('\n'));
+        }
+    }
+}
+function updateGitIgnore(tree) {
+    const gitignore = tree.exists('.gitignore')
+        ? tree.read('.gitignore', 'utf-8')
+        : '';
+    const ig = (0, ignore_1.default)();
+    ig.add(gitignore);
+    if (!ig.ignores('.nx/cache')) {
+        const updatedLines = gitignore.length
+            ? [gitignore, '.nx/cache']
+            : ['.nx/cache'];
+        tree.write('.gitignore', updatedLines.join('\n'));
+    }
+}

package/src/migrations/update-17-0-0/rm-default-collection-npm-scope.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '../../generators/tree';
+export default function update(tree: Tree): Promise<void>;

package/src/migrations/update-17-0-0/rm-default-collection-npm-scope.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const nx_json_1 = require("../../generators/utils/nx-json");
+const json_1 = require("../../generators/utils/json");
+const output_1 = require("../../utils/output");
+const path_1 = require("../../utils/path");
+async function update(tree) {
+    if (!tree.exists('nx.json')) {
+        return;
+    }
+    const nxJson = (0, nx_json_1.readNxJson)(tree);
+    delete nxJson.cli?.['defaultCollection'];
+    if (nxJson?.cli && Object.keys(nxJson.cli).length < 1) {
+        delete nxJson.cli;
+    }
+    warnNpmScopeHasChanged(tree, nxJson);
+    delete nxJson['npmScope'];
+    (0, nx_json_1.updateNxJson)(tree, nxJson);
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}
+function warnNpmScopeHasChanged(tree, nxJson) {
+    const originalScope = nxJson['npmScope'];
+    // There was no original scope
+    if (!originalScope) {
+        return false;
+    }
+    // package.json does not exist
+    if (!tree.exists('package.json')) {
+        return false;
+    }
+    const newScope = getNpmScopeFromPackageJson(tree);
+    // New and Original scope are the same.
+    if (originalScope === newScope) {
+        return false;
+    }
+    const packageJsonName = (0, json_1.readJson)(tree, 'package.json').name;
+    if (newScope) {
+        output_1.output.warn({
+            title: 'npmScope has been removed from nx.json',
+            bodyLines: [
+                'This will now be read from package.json',
+                `Old value which was in nx.json: ${originalScope}`,
+                `New value from package.json: ${newScope}`,
+                `Typescript path mappings for new libraries will now be generated as such: @${newScope}/new-lib instead of @${originalScope}/new-lib`,
+                `If you would like to change this back, change the name in package.json to ${packageJsonName.replace(newScope, originalScope)}`,
+            ],
+        });
+    }
+    else {
+        // There is no scope in package.json
+        output_1.output.warn({
+            title: 'npmScope has been removed from nx.json',
+            bodyLines: [
+                'This will now be read from package.json',
+                `Old value which was in nx.json: ${originalScope}`,
+                `New value from package.json: null`,
+                `Typescript path mappings for new libraries will now be generated as such: new-lib instead of @${originalScope}/new-lib`,
+                `If you would like to change this back, change the name in package.json to ${(0, path_1.joinPathFragments)(`@${originalScope}`, packageJsonName)}`,
+            ],
+        });
+    }
+}
+function getNpmScopeFromPackageJson(tree) {
+    const { name } = tree.exists('package.json')
+        ? (0, json_1.readJson)(tree, 'package.json')
+        : { name: null };
+    if (name?.startsWith('@')) {
+        return name.split('/')[0].substring(1);
+    }
+}

package/src/migrations/update-17-0-0/use-minimal-config-for-tasks-runner-options.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '../../generators/tree';
+export default function migrate(tree: Tree): Promise<void>;

package/src/migrations/update-17-0-0/use-minimal-config-for-tasks-runner-options.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrate;
+const json_1 = require("../../generators/utils/json");
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const nx_json_1 = require("../../generators/utils/nx-json");
+const update_manager_1 = require("../../nx-cloud/update-manager");
+const run_command_1 = require("../../tasks-runner/run-command");
+const output_1 = require("../../utils/output");
+async function migrate(tree) {
+    if (!tree.exists('nx.json')) {
+        return;
+    }
+    const nxJson = (0, nx_json_1.readNxJson)(tree);
+    // Already migrated
+    if (!nxJson.tasksRunnerOptions?.default) {
+        return;
+    }
+    const nxCloudClientSupported = await isNxCloudClientSupported(nxJson);
+    (0, json_1.updateJson)(tree, 'nx.json', (nxJson) => {
+        const { runner, options } = nxJson.tasksRunnerOptions.default;
+        // This property shouldn't ever be part of tasks runner options.
+        if (options.useDaemonProcess !== undefined) {
+            nxJson.useDaemonProcess = options.useDaemonProcess;
+            delete options.useDaemonProcess;
+        }
+        // Remaining keys may be specific to a given runner, so leave them alone if there are multiple runners.
+        if (Object.keys(nxJson.tasksRunnerOptions ?? {}).length > 1) {
+            return nxJson;
+        }
+        // These options can only be moved for nx-cloud.
+        if (runner === 'nx-cloud' || runner === '@nrwl/nx-cloud') {
+            nxJson.nxCloudAccessToken = options.accessToken;
+            delete options.accessToken;
+            if (options.url) {
+                nxJson.nxCloudUrl = options.url;
+                delete options.url;
+            }
+            if (nxCloudClientSupported) {
+                removeNxCloudDependency(tree);
+            }
+            else {
+                options.useLightClient = false;
+            }
+            if (options.encryptionKey) {
+                nxJson.nxCloudEncryptionKey = options.encryptionKey;
+                delete options.encryptionKey;
+            }
+        }
+        // These options should be safe to move for all tasks runners:
+        if (options.parallel !== undefined) {
+            nxJson.parallel = options.parallel;
+            delete options.parallel;
+        }
+        if (options.cacheDirectory !== undefined) {
+            nxJson.cacheDirectory = options.cacheDirectory;
+            delete options.cacheDirectory;
+        }
+        if (Array.isArray(options.cacheableOperations)) {
+            nxJson.targetDefaults ??= {};
+            for (const target of options.cacheableOperations) {
+                nxJson.targetDefaults[target] ??= {};
+                nxJson.targetDefaults[target].cache ??= true;
+            }
+            delete options.cacheableOperations;
+        }
+        if (['nx-cloud', '@nrwl/nx-cloud', 'nx/tasks-runners/default'].includes(runner)) {
+            delete nxJson.tasksRunnerOptions.default.runner;
+            if (Object.values(options).length === 0) {
+                delete nxJson.tasksRunnerOptions;
+            }
+        }
+        return nxJson;
+    });
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}
+async function isNxCloudClientSupported(nxJson) {
+    const nxCloudOptions = (0, run_command_1.getRunnerOptions)('default', nxJson, {}, true);
+    // Non enterprise workspaces support the Nx Cloud Client
+    if (!isNxCloudEnterpriseWorkspace(nxJson)) {
+        return true;
+    }
+    // If we can get the nx cloud client, it's supported
+    try {
+        await (0, update_manager_1.verifyOrUpdateNxCloudClient)(nxCloudOptions);
+        return true;
+    }
+    catch (e) {
+        if (e instanceof update_manager_1.NxCloudEnterpriseOutdatedError) {
+            output_1.output.warn({
+                title: 'Nx Cloud Instance is outdated.',
+                bodyLines: [
+                    'If you are an Nx Enterprise customer, please reach out to your assigned Developer Productivity Engineer.',
+                    'If you are NOT an Nx Enterprise customer but are seeing this message, please reach out to cloud-support@nrwl.io.',
+                ],
+            });
+        }
+        return false;
+    }
+}
+function isNxCloudEnterpriseWorkspace(nxJson) {
+    const { runner, options } = nxJson.tasksRunnerOptions.default;
+    return ((runner === 'nx-cloud' || runner === '@nrwl/nx-cloud') &&
+        options.url &&
+        ![
+            'https://nx.app',
+            'https://cloud.nx.app',
+            'https://staging.nx.app',
+            'https://snapshot.nx.app',
+        ].includes(options.url));
+}
+function removeNxCloudDependency(tree) {
+    if (tree.exists('package.json')) {
+        (0, json_1.updateJson)(tree, 'package.json', (packageJson) => {
+            delete packageJson.dependencies?.['nx-cloud'];
+            delete packageJson.devDependencies?.['nx-cloud'];
+            delete packageJson.dependencies?.['@nrwl/nx-cloud'];
+            delete packageJson.devDependencies?.['@nrwl/nx-cloud'];
+            return packageJson;
+        });
+    }
+}

package/src/migrations/update-17-2-0/move-default-base.d.ts

@@ -0,0 +1,5 @@
+import { Tree } from '../../generators/tree';
+/**
+ * Updates existing workspaces to move nx.json's affected.defaultBase to nx.json's base.
+ */
+export default function update(host: Tree): Promise<void>;

package/src/migrations/update-17-2-0/move-default-base.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const nx_json_1 = require("../../generators/utils/nx-json");
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+/**
+ * Updates existing workspaces to move nx.json's affected.defaultBase to nx.json's base.
+ */
+async function update(host) {
+    const nxJson = (0, nx_json_1.readNxJson)(host);
+    if (nxJson?.affected?.defaultBase) {
+        nxJson.defaultBase = nxJson.affected.defaultBase;
+        delete nxJson.affected.defaultBase;
+        if (Object.keys(nxJson.affected).length === 0) {
+            delete nxJson.affected;
+        }
+        (0, nx_json_1.updateNxJson)(host, nxJson);
+    }
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(host);
+}

package/src/migrations/update-17-3-0/nx-release-path.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '../../generators/tree';
+export default function nxReleasePath(tree: Tree): void;
+export declare function visitNotIgnoredFiles(tree: Tree, dirPath: string, visitor: (path: string) => void): void;

package/src/migrations/update-17-3-0/nx-release-path.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = nxReleasePath;
+exports.visitNotIgnoredFiles = visitNotIgnoredFiles;
+const node_path_1 = require("node:path");
+const ignore_1 = require("../../utils/ignore");
+function nxReleasePath(tree) {
+    visitNotIgnoredFiles(tree, '', (file) => {
+        const contents = tree.read(file).toString('utf-8');
+        if (
+        // the deep import usage should be replaced by the new location
+        contents.includes('nx/src/command-line/release') ||
+            // changelog-renderer has moved into nx/release
+            contents.includes('nx/changelog-renderer')) {
+            const finalContents = contents
+                // replace instances of old changelog renderer location
+                .replace(/nx\/changelog-renderer/g, 'nx/release/changelog-renderer')
+                // replace instances of deep import for programmatic API (only perform the replacement if an actual import by checking for trailing ' or ")
+                .replace(/nx\/src\/command-line\/release(['"])/g, 'nx/release$1');
+            tree.write(file, finalContents);
+        }
+    });
+}
+// Adapted from devkit
+function visitNotIgnoredFiles(tree, dirPath = tree.root, visitor) {
+    const ig = (0, ignore_1.getIgnoreObject)();
+    dirPath = normalizePathRelativeToRoot(dirPath, tree.root);
+    if (dirPath !== '' && ig?.ignores(dirPath)) {
+        return;
+    }
+    for (const child of tree.children(dirPath)) {
+        const fullPath = (0, node_path_1.join)(dirPath, child);
+        if (ig?.ignores(fullPath)) {
+            continue;
+        }
+        if (tree.isFile(fullPath)) {
+            visitor(fullPath);
+        }
+        else {
+            visitNotIgnoredFiles(tree, fullPath, visitor);
+        }
+    }
+}
+// Copied from devkit
+function normalizePathRelativeToRoot(path, root) {
+    return (0, node_path_1.relative)(root, (0, node_path_1.join)(root, path)).split(node_path_1.sep).join('/');
+}

package/src/migrations/update-18-0-0/disable-crystal-for-existing-workspaces.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '../../generators/tree';
+export default function migrate(tree: Tree): Promise<void>;

package/src/migrations/update-18-0-0/disable-crystal-for-existing-workspaces.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrate;
+const nx_json_1 = require("../../generators/utils/nx-json");
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+async function migrate(tree) {
+    const nxJson = (0, nx_json_1.readNxJson)(tree);
+    nxJson.useInferencePlugins = false;
+    (0, nx_json_1.updateNxJson)(tree, nxJson);
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}

package/src/migrations/update-21-1-0/add-gitignore-entry.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '../../generators/tree';
+export default function addGitignoreEntry(tree: Tree): Promise<void>;

package/src/migrations/update-21-1-0/add-gitignore-entry.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = addGitignoreEntry;
+const ignore_1 = require("ignore");
+async function addGitignoreEntry(tree) {
+    if (!tree.exists('nx.json')) {
+        return;
+    }
+    const GITIGNORE_ENTRIES = [
+        '.cursor/rules/nx-rules.mdc',
+        '.github/instructions/nx.instructions.md',
+    ];
+    if (!tree.exists('.gitignore')) {
+        return;
+    }
+    let content = tree.read('.gitignore', 'utf-8') || '';
+    const ig = (0, ignore_1.default)().add(content);
+    for (const entry of GITIGNORE_ENTRIES) {
+        if (!ig.ignores(entry)) {
+            content = content.trimEnd() + '\n' + entry + '\n';
+        }
+    }
+    tree.write('.gitignore', content);
+}

package/src/native/index.d.ts

@@ -8,7 +8,7 @@ export declare class ExternalObject<T> {
   }
 }
 export declare class AppLifeCycle {
-  constructor(tasks: Array<Task>, initiatingTasks: Array<string>, runMode: RunMode, pinnedTasks: Array<string>, tuiCliArgs: TuiCliArgs, tuiConfig: TuiConfig, titleText: string)
+  constructor(tasks: Array<Task>, initiatingTasks: Array<string>, runMode: RunMode, pinnedTasks: Array<string>, tuiCliArgs: TuiCliArgs, tuiConfig: TuiConfig, titleText: string, workspaceRoot: string)
   startCommand(threadCount?: number | undefined | null): void
   scheduleTask(task: Task): void
   startTasks(tasks: Array<Task>, metadata: object): void

package/src/native/index.js

@@ -62,10 +62,15 @@ const originalLoad = Module._load;
 // Will only be called once because the require cache takes over afterwards.
 Module._load = function (request, parent, isMain) {
   const modulePath = request;
-  if (
+  // Check if we should use the native file cache (enabled by default)
+  const useNativeFileCache = process.env.NX_SKIP_NATIVE_FILE_CACHE !== 'true';
+  // Check if this is an Nx native module (either from npm or local file)
+  const isNxNativeModule =
     nxPackages.has(modulePath) ||
-    localNodeFiles.some((f) => modulePath.endsWith(f))
-  ) {
+    localNodeFiles.some((file) => modulePath.endsWith(file));
+
+  // Only use the file cache for Nx native modules when caching is enabled
+  if (useNativeFileCache && isNxNativeModule) {
     const nativeLocation = require.resolve(modulePath);
     const fileName = basename(nativeLocation);
 

package/src/plugins/js/project-graph/affected/lock-file-changes.d.ts

@@ -1,4 +1,5 @@
 import { TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
 import { WholeFileChange } from '../../../../project-graph/file-utils';
 import { JsonChange } from '../../../../utils/json-diff';
+export declare const PNPM_LOCK_FILES: string[];
 export declare const getTouchedProjectsFromLockFile: TouchedProjectLocator<WholeFileChange | JsonChange>;

package/src/plugins/js/project-graph/affected/lock-file-changes.js

@@ -1,29 +1,69 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTouchedProjectsFromLockFile = void 0;
+exports.getTouchedProjectsFromLockFile = exports.PNPM_LOCK_FILES = void 0;
 const configuration_1 = require("../../../../config/configuration");
+const json_diff_1 = require("../../../../utils/json-diff");
 const config_1 = require("../../utils/config");
 const find_matching_projects_1 = require("../../../../utils/find-matching-projects");
+exports.PNPM_LOCK_FILES = ['pnpm-lock.yaml', 'pnpm-lock.yml'];
+const ALL_LOCK_FILES = [
+    ...exports.PNPM_LOCK_FILES,
+    'package-lock.json',
+    'yarn.lock',
+    'bun.lockb',
+    'bun.lock',
+];
 const getTouchedProjectsFromLockFile = (fileChanges, projectGraphNodes) => {
     const nxJson = (0, configuration_1.readNxJson)();
     const { projectsAffectedByDependencyUpdates } = (0, config_1.jsPluginConfig)(nxJson);
+    const changedLockFile = fileChanges.find((f) => ALL_LOCK_FILES.includes(f.file));
     if (projectsAffectedByDependencyUpdates === 'auto') {
-        return [];
+        const changedProjectPaths = getProjectPathsAffectedByDependencyUpdates(changedLockFile);
+        const changedProjectNames = getProjectsNamesFromPaths(projectGraphNodes, changedProjectPaths);
+        return changedProjectNames;
     }
     else if (Array.isArray(projectsAffectedByDependencyUpdates)) {
         return (0, find_matching_projects_1.findMatchingProjects)(projectsAffectedByDependencyUpdates, projectGraphNodes);
     }
-    const lockFiles = [
-        'package-lock.json',
-        'yarn.lock',
-        'pnpm-lock.yaml',
-        'pnpm-lock.yml',
-        'bun.lockb',
-        'bun.lock',
-    ];
-    if (fileChanges.some((f) => lockFiles.includes(f.file))) {
+    if (changedLockFile) {
         return Object.values(projectGraphNodes).map((p) => p.name);
     }
     return [];
 };
 exports.getTouchedProjectsFromLockFile = getTouchedProjectsFromLockFile;
+/**
+ * For pnpm projects, check lock file for changes to importers and return the project paths that have changes.
+ */
+const getProjectPathsAffectedByDependencyUpdates = (changedLockFile) => {
+    if (!changedLockFile) {
+        return [];
+    }
+    const changedProjectPaths = new Set();
+    if (exports.PNPM_LOCK_FILES.includes(changedLockFile.file)) {
+        for (const change of changedLockFile.getChanges()) {
+            if ((0, json_diff_1.isJsonChange)(change) &&
+                change.path[0] === 'importers' &&
+                change.path[1] !== undefined) {
+                changedProjectPaths.add(change.path[1]);
+            }
+        }
+    }
+    return Array.from(changedProjectPaths);
+};
+const getProjectsNamesFromPaths = (projectGraphNodes, projectPaths) => {
+    const lookup = new RootPathLookup(projectGraphNodes);
+    return projectPaths.map((path) => {
+        return lookup.findNodeNameByRoot(path);
+    });
+};
+class RootPathLookup {
+    constructor(nodes) {
+        this.rootToNameMap = new Map();
+        Object.entries(nodes).forEach(([name, node]) => {
+            this.rootToNameMap.set(node.data.root, name);
+        });
+    }
+    findNodeNameByRoot(root) {
+        return this.rootToNameMap.get(root);
+    }
+}

package/src/project-graph/file-utils.js

@@ -61,6 +61,17 @@ function calculateFileChanges(files, allWorkspaceFiles, nxArgs, readFileAtRevisi
                         catch (e) {
                             return [new WholeFileChange()];
                         }
+                    case '.yml':
+                    case '.yaml':
+                        const { load } = require('@zkochan/js-yaml');
+                        try {
+                            const atBase = readFileAtRevision(f, nxArgs.base);
+                            const atHead = readFileAtRevision(f, nxArgs.head);
+                            return (0, json_diff_1.jsonDiff)(load(atBase), load(atHead));
+                        }
+                        catch (e) {
+                            return [new WholeFileChange()];
+                        }
                     default:
                         return [new WholeFileChange()];
                 }

package/src/tasks-runner/run-command.js

@@ -128,7 +128,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
         const lifeCycles = [tsLifeCycle];
         // Only run the TUI if there are tasks to run
         if (tasks.length > 0) {
-            appLifeCycle = new AppLifeCycle(tasks, initiatingTasks.map((t) => t.id), isRunOne ? 0 /* RunMode.RunOne */ : 1 /* RunMode.RunMany */, pinnedTasks, nxArgs ?? {}, nxJson.tui ?? {}, titleText);
+            appLifeCycle = new AppLifeCycle(tasks, initiatingTasks.map((t) => t.id), isRunOne ? 0 /* RunMode.RunOne */ : 1 /* RunMode.RunMany */, pinnedTasks, nxArgs ?? {}, nxJson.tui ?? {}, titleText, workspace_root_1.workspaceRoot);
             lifeCycles.unshift(appLifeCycle);
             /**
              * Patch stdout.write and stderr.write methods to pass Nx Cloud client logs to the TUI via the lifecycle

package/src/tasks-runner/running-tasks/node-child-process.js

@@ -96,8 +96,8 @@ function addPrefixTransformer(prefix) {
 const colors = [
     chalk.green,
     chalk.greenBright,
-    chalk.red,
-    chalk.redBright,
+    chalk.blue,
+    chalk.blueBright,
     chalk.cyan,
     chalk.cyanBright,
     chalk.yellow,