nx 19.0.0-beta.1 → 19.0.0-beta.10

package/src/project-graph/plugins/loader.js

@@ -8,7 +8,6 @@ const package_json_1 = require("../../utils/package-json");
 const fileutils_1 = require("../../utils/fileutils");
 const workspace_root_1 = require("../../utils/workspace-root");
 const node_fs_1 = require("node:fs");
-const typescript_1 = require("../../utils/typescript");
 const register_1 = require("../../plugins/js/utils/register");
 const find_project_for_path_1 = require("../utils/find-project-for-path");
 const path_1 = require("../../utils/path");
@@ -19,6 +18,7 @@ const utils_1 = require("./utils");
 const internal_api_1 = require("./internal-api");
 const error_types_1 = require("../error-types");
 const path = require("node:path/posix");
+const typescript_1 = require("../../plugins/js/utils/typescript");
 function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
     try {
         const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
@@ -32,6 +32,9 @@ function readPluginPackageJson(pluginName, projects, paths = (0, installation_di
             const localPluginPath = resolveLocalNxPlugin(pluginName, projects);
             if (localPluginPath) {
                 const localPluginPackageJson = path.join(localPluginPath.path, 'package.json');
+                if (!exports.unregisterPluginTSTranspiler) {
+                    registerPluginTSTranspiler();
+                }
                 return {
                     path: localPluginPackageJson,
                     json: (0, fileutils_1.readJsonFile)(localPluginPackageJson),
@@ -77,22 +80,27 @@ function registerPluginTSTranspiler() {
 }
 exports.registerPluginTSTranspiler = registerPluginTSTranspiler;
 function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
-    const plugin = findNxProjectForImportPath(importPath, projects, root);
-    if (!plugin) {
+    const projectConfig = findNxProjectForImportPath(importPath, projects, root);
+    if (!projectConfig) {
         return null;
     }
-    const projectConfig = projects[plugin];
     return { path: path.join(root, projectConfig.root), projectConfig };
 }
 function findNxProjectForImportPath(importPath, projects, root = workspace_root_1.workspaceRoot) {
     const tsConfigPaths = readTsConfigPaths(root);
     const possiblePaths = tsConfigPaths[importPath]?.map((p) => (0, path_1.normalizePath)(path.relative(root, path.join(root, p))));
     if (possiblePaths?.length) {
-        const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projects);
+        const projectRootMappings = new Map();
+        const projectNameMap = new Map();
+        for (const projectRoot in projects) {
+            const project = projects[projectRoot];
+            projectRootMappings.set(project.root, project.name);
+            projectNameMap.set(project.name, project);
+        }
         for (const tsConfigPath of possiblePaths) {
             const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
             if (nxProject) {
-                return nxProject;
+                return projectNameMap.get(nxProject);
             }
         }
         logger_1.logger.verbose('Unable to find local plugin', possiblePaths, projectRootMappings);

package/src/project-graph/plugins/public-api.d.ts

@@ -12,7 +12,7 @@ export interface CreateNodesContext {
     /**
      * The subset of configuration files which match the createNodes pattern
      */
-    readonly configFiles: string[];
+    readonly configFiles: readonly string[];
 }
 /**
  * A function which parses a configuration file into a set of nodes.
@@ -68,6 +68,12 @@ export interface CreateDependenciesContext {
  * Use {@link validateDependency} to validate dependencies
  */
 export type CreateDependencies<T = unknown> = (options: T | undefined, context: CreateDependenciesContext) => RawProjectGraphDependency[] | Promise<RawProjectGraphDependency[]>;
+export type CreateMetadataContext = {
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+    readonly workspaceRoot: string;
+};
+export type ProjectsMetadata = Record<string, Pick<ProjectConfiguration, 'metadata'>>;
+export type CreateMetadata<T = unknown> = (graph: ProjectGraph, options: T | undefined, context: CreateMetadataContext) => ProjectsMetadata | Promise<ProjectsMetadata>;
 /**
  * A plugin for Nx which creates nodes and dependencies for the {@link ProjectGraph}
  */
@@ -82,6 +88,10 @@ export type NxPluginV2<TOptions = unknown> = {
      * Provides a function to analyze files to create dependencies for the {@link ProjectGraph}
      */
     createDependencies?: CreateDependencies<TOptions>;
+    /**
+     * Provides a function to create metadata for the {@link ProjectGraph}
+     */
+    createMetadata?: CreateMetadata<TOptions>;
 };
 /**
  * A plugin for Nx

package/src/project-graph/plugins/utils.d.ts

@@ -1,7 +1,7 @@
 import type { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
 import type { CreateNodesResultWithContext, LoadedNxPlugin, NormalizedPlugin } from './internal-api';
-import type { CreateNodesContext, NxPlugin, NxPluginV2 } from './public-api';
+import { type CreateNodesContext, type NxPlugin, type NxPluginV2 } from './public-api';
 export declare function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2;
 export declare function isNxPluginV1(plugin: NxPlugin | LoadedNxPlugin): plugin is NxPluginV1;
 export declare function normalizeNxPlugin(plugin: NxPlugin): NormalizedPlugin;
-export declare function runCreateNodesInParallel(configFiles: string[], plugin: NormalizedPlugin, options: unknown, context: CreateNodesContext): Promise<CreateNodesResultWithContext[]>;
+export declare function runCreateNodesInParallel(configFiles: readonly string[], plugin: NormalizedPlugin, options: unknown, context: CreateNodesContext): Promise<CreateNodesResultWithContext[]>;

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

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCreateNodesInParallel = exports.normalizeNxPlugin = exports.isNxPluginV1 = exports.isNxPluginV2 = void 0;
 const node_path_1 = require("node:path");
-const workspaces_1 = require("../../config/workspaces");
+const to_project_name_1 = require("../../config/to-project-name");
 const globs_1 = require("../../utils/globs");
 const error_types_1 = require("../error-types");
+const perf_hooks_1 = require("perf_hooks");
 function isNxPluginV2(plugin) {
     return 'createNodes' in plugin || 'createDependencies' in plugin;
 }
@@ -27,7 +28,7 @@ function normalizeNxPlugin(plugin) {
                     return {
                         projects: {
                             [root]: {
-                                name: (0, workspaces_1.toProjectName)(configFilePath),
+                                name: (0, to_project_name_1.toProjectName)(configFilePath),
                                 targets: plugin.registerProjectTargets?.(configFilePath),
                             },
                         },
@@ -40,37 +41,31 @@ function normalizeNxPlugin(plugin) {
 }
 exports.normalizeNxPlugin = normalizeNxPlugin;
 async function runCreateNodesInParallel(configFiles, plugin, options, context) {
-    performance.mark(`${plugin.name}:createNodes - start`);
+    perf_hooks_1.performance.mark(`${plugin.name}:createNodes - start`);
     const errors = [];
     const results = [];
-    const promises = configFiles.map((file) => {
-        performance.mark(`${plugin.name}:createNodes:${file} - start`);
-        // Result is either static or a promise, using Promise.resolve lets us
-        // handle both cases with same logic
-        const value = Promise.resolve(plugin.createNodes[1](file, options, context));
-        return value
-            .catch((e) => {
-            performance.mark(`${plugin.name}:createNodes:${file} - end`);
+    const promises = configFiles.map(async (file) => {
+        try {
+            const value = await plugin.createNodes[1](file, options, context);
+            if (value) {
+                results.push({
+                    ...value,
+                    file,
+                    pluginName: plugin.name,
+                });
+            }
+        }
+        catch (e) {
             errors.push(new error_types_1.CreateNodesError({
                 error: e,
                 pluginName: plugin.name,
                 file,
             }));
-            return null;
-        })
-            .then((r) => {
-            performance.mark(`${plugin.name}:createNodes:${file} - end`);
-            performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
-            // Existing behavior is to ignore null results of
-            // createNodes function.
-            if (r) {
-                results.push({ ...r, file, pluginName: plugin.name });
-            }
-        });
+        }
     });
     await Promise.all(promises).then(() => {
-        performance.mark(`${plugin.name}:createNodes - end`);
-        performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
+        perf_hooks_1.performance.mark(`${plugin.name}:createNodes - end`);
+        perf_hooks_1.performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
     });
     if (errors.length > 0) {
         throw new error_types_1.AggregateCreateNodesError(plugin.name, errors, results);

package/src/project-graph/project-graph.d.ts

@@ -14,6 +14,9 @@ export declare function buildProjectGraphAndSourceMapsWithoutDaemon(): Promise<{
     projectGraph: ProjectGraph;
     sourceMaps: import("./utils/project-configuration-utils").ConfigurationSourceMaps;
 }>;
+export declare function handleProjectGraphError(opts: {
+    exitOnError: boolean;
+}, e: any): void;
 /**
  * Computes and returns a ProjectGraph.
  *

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createProjectGraphAndSourceMapsAsync = exports.createProjectGraphAsync = exports.buildProjectGraphAndSourceMapsWithoutDaemon = exports.readProjectsConfigurationFromProjectGraph = exports.readCachedProjectConfiguration = exports.readCachedProjectGraph = void 0;
+exports.createProjectGraphAndSourceMapsAsync = exports.createProjectGraphAsync = exports.handleProjectGraphError = exports.buildProjectGraphAndSourceMapsWithoutDaemon = exports.readProjectsConfigurationFromProjectGraph = exports.readCachedProjectConfiguration = exports.readCachedProjectGraph = void 0;
 const perf_hooks_1 = require("perf_hooks");
 const nx_json_1 = require("../config/nx-json");
 const client_1 = require("../daemon/client/client");
@@ -10,8 +10,8 @@ const output_1 = require("../utils/output");
 const strip_indents_1 = require("../utils/strip-indents");
 const workspace_root_1 = require("../utils/workspace-root");
 const build_project_graph_1 = require("./build-project-graph");
-const nx_deps_cache_1 = require("./nx-deps-cache");
 const error_types_1 = require("./error-types");
+const nx_deps_cache_1 = require("./nx-deps-cache");
 const internal_api_1 = require("./plugins/internal-api");
 const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
 /**
@@ -92,18 +92,18 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     perf_hooks_1.performance.mark('retrieve-workspace-files:end');
     const cacheEnabled = process.env.NX_CACHE_PROJECT_GRAPH !== 'false';
     perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:start');
-    let createDependenciesError;
+    let projectGraphError;
     let projectGraphResult;
     try {
-        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, plugins);
+        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, plugins, sourceMaps);
     }
     catch (e) {
-        if (e instanceof build_project_graph_1.CreateDependenciesError) {
+        if ((0, error_types_1.isAggregateProjectGraphError)(e)) {
             projectGraphResult = {
                 projectGraph: e.partialProjectGraph,
                 projectFileMapCache: null,
             };
-            createDependenciesError = e;
+            projectGraphError = e;
         }
         else {
             throw e;
@@ -117,7 +117,7 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     delete global.NX_GRAPH_CREATION;
     const errors = [
         ...(projectConfigurationsError?.errors ?? []),
-        ...(createDependenciesError?.errors ?? []),
+        ...(projectGraphError?.errors ?? []),
     ];
     if (errors.length > 0) {
         throw new error_types_1.ProjectGraphError(errors, projectGraph, sourceMaps);
@@ -162,6 +162,7 @@ function handleProjectGraphError(opts, e) {
         throw e;
     }
 }
+exports.handleProjectGraphError = handleProjectGraphError;
 /**
  * Computes and returns a ProjectGraph.
  *

package/src/project-graph/utils/find-project-for-path.js

@@ -9,9 +9,8 @@ const path_2 = require("../../utils/path");
  */
 function createProjectRootMappingsFromProjectConfigurations(projects) {
     const projectRootMappings = new Map();
-    for (const projectName of Object.keys(projects)) {
-        const root = projects[projectName].root;
-        projectRootMappings.set(normalizeProjectRoot(root), projectName);
+    for (const { name, root } of Object.values(projects)) {
+        projectRootMappings.set(normalizeProjectRoot(root), name);
     }
     return projectRootMappings;
 }

package/src/project-graph/utils/normalize-project-nodes.d.ts

@@ -2,7 +2,7 @@ import { ProjectGraphProjectNode } from '../../config/project-graph';
 import { ProjectGraphBuilder } from '../project-graph-builder';
 import { ProjectConfiguration, TargetConfiguration } from '../../config/workspace-json-project-json';
 import { CreateDependenciesContext } from '../plugins';
-export declare function normalizeProjectNodes(ctx: CreateDependenciesContext, builder: ProjectGraphBuilder): Promise<void>;
+export declare function normalizeProjectNodes({ projects }: CreateDependenciesContext, builder: ProjectGraphBuilder): Promise<void>;
 /**
  * Apply target defaults and normalization
  */

package/src/project-graph/utils/normalize-project-nodes.js

@@ -2,16 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeImplicitDependencies = exports.normalizeProjectTargets = exports.normalizeProjectNodes = void 0;
 const find_matching_projects_1 = require("../../utils/find-matching-projects");
-const project_configuration_utils_1 = require("../utils/project-configuration-utils");
-async function normalizeProjectNodes(ctx, builder) {
-    const toAdd = [];
+async function normalizeProjectNodes({ projects }, builder) {
     // Sorting projects by name to make sure that the order of projects in the graph is deterministic.
     // This is important to ensure that expanded properties referencing projects (e.g. implicit dependencies)
     // are also deterministic, and thus don't cause the calculated project configuration hash to shift.
-    const projects = Object.keys(ctx.projects).sort();
+    const sortedProjectNames = Object.keys(projects).sort();
     // Used for expanding implicit dependencies (e.g. `@proj/*` or `tag:foo`)
-    const partialProjectGraphNodes = projects.reduce((graph, project) => {
-        const projectConfiguration = ctx.projects[project];
+    const partialProjectGraphNodes = sortedProjectNames.reduce((graph, project) => {
+        const projectConfiguration = projects[project];
         graph[project] = {
             name: project,
             type: projectConfiguration.projectType === 'library' ? 'lib' : 'app', // missing fallback to `e2e`
@@ -21,8 +19,9 @@ async function normalizeProjectNodes(ctx, builder) {
         };
         return graph;
     }, {});
-    for (const key of projects) {
-        const p = ctx.projects[key];
+    const toAdd = [];
+    for (const key of sortedProjectNames) {
+        const p = projects[key];
         p.implicitDependencies = normalizeImplicitDependencies(key, p.implicitDependencies, partialProjectGraphNodes);
         p.targets = normalizeProjectTargets(p, key);
         // TODO: remove in v16
@@ -31,7 +30,7 @@ async function normalizeProjectNodes(ctx, builder) {
                 ? 'e2e'
                 : 'app'
             : 'lib';
-        const tags = ctx.projects?.[key]?.tags || [];
+        const tags = p.tags || [];
         toAdd.push({
             name: key,
             type: projectType,
@@ -69,11 +68,6 @@ function normalizeProjectTargets(project, projectName) {
             delete targets[target];
             continue;
         }
-        targets[target].options = (0, project_configuration_utils_1.resolveNxTokensInOptions)(targets[target].options, project, `${projectName}:${target}`);
-        targets[target].configurations ??= {};
-        for (const configuration in targets[target].configurations) {
-            targets[target].configurations[configuration] = (0, project_configuration_utils_1.resolveNxTokensInOptions)(targets[target].configurations[configuration], project, `${projectName}:${target}:${configuration}`);
-        }
     }
     return targets;
 }

package/src/project-graph/utils/project-configuration-utils.d.ts

@@ -1,20 +1,36 @@
 import { NxJsonConfiguration, TargetDefaults } from '../../config/nx-json';
 import { ProjectGraphExternalNode } from '../../config/project-graph';
-import { ProjectConfiguration, TargetConfiguration } from '../../config/workspace-json-project-json';
+import { ProjectConfiguration, ProjectMetadata, TargetConfiguration, TargetMetadata } from '../../config/workspace-json-project-json';
 import { ONLY_MODIFIES_EXISTING_TARGET } from '../../plugins/target-defaults/symbols';
 import { LoadedNxPlugin } from '../plugins/internal-api';
-export type SourceInformation = [file: string, plugin: string];
+export type SourceInformation = [file: string | null, plugin: string];
 export type ConfigurationSourceMaps = Record<string, Record<string, SourceInformation>>;
-export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Map<string, ProjectConfiguration>, project: ProjectConfiguration & {
+export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Record<string, ProjectConfiguration>, project: ProjectConfiguration & {
     targets?: Record<string, TargetConfiguration & {
         [ONLY_MODIFIES_EXISTING_TARGET]?: boolean;
     }>;
-}, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation, skipCommandNormalization?: boolean): void;
+}, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation, skipTargetNormalization?: boolean): void;
+export declare function mergeMetadata<T = ProjectMetadata | TargetMetadata>(sourceMap: Record<string, [file: string, plugin: string]>, sourceInformation: [file: string, plugin: string], baseSourceMapPath: string, metadata: T, matchingMetadata?: T): T;
 export type ConfigurationResult = {
-    projects: Record<string, ProjectConfiguration>;
+    /**
+     * A map of project configurations, keyed by project root.
+     */
+    projects: {
+        [projectRoot: string]: ProjectConfiguration;
+    };
+    /**
+     * Node Name -> Node info
+     */
     externalNodes: Record<string, ProjectGraphExternalNode>;
+    /**
+     * Project Root -> Project Name
+     */
     projectRootMap: Record<string, string>;
     sourceMaps: ConfigurationSourceMaps;
+    /**
+     * The list of files that were used to create project configurations
+     */
+    matchingProjectFiles: string[];
 };
 /**
  * Transforms a list of project paths into a map of project configurations.
@@ -26,7 +42,7 @@ export type ConfigurationResult = {
  */
 export declare function createProjectConfigurations(root: string, nxJson: NxJsonConfiguration, projectFiles: string[], // making this parameter allows devkit to pick up newly created projects
 plugins: LoadedNxPlugin[]): Promise<ConfigurationResult>;
-export declare function readProjectConfigurationsFromRootMap(projectRootMap: Map<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
+export declare function readProjectConfigurationsFromRootMap(projectRootMap: Record<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
 /**
  * Merges two targets.
  *
@@ -51,3 +67,4 @@ export declare function mergeTargetConfigurations(target: TargetConfiguration, b
 export declare function isCompatibleTarget(a: TargetConfiguration, b: TargetConfiguration): boolean;
 export declare function resolveNxTokensInOptions<T extends Object | Array<unknown>>(object: T, project: ProjectConfiguration, key: string): T;
 export declare function readTargetDefaultsForTarget(targetName: string, targetDefaults: TargetDefaults, executor?: string): TargetDefaults[string];
+export declare function normalizeTarget(target: TargetConfiguration, project: ProjectConfiguration): TargetConfiguration<any>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readTargetDefaultsForTarget = exports.resolveNxTokensInOptions = exports.isCompatibleTarget = exports.mergeTargetConfigurations = exports.readProjectConfigurationsFromRootMap = exports.createProjectConfigurations = exports.mergeProjectConfigurationIntoRootMap = void 0;
+exports.normalizeTarget = exports.readTargetDefaultsForTarget = exports.resolveNxTokensInOptions = exports.isCompatibleTarget = exports.mergeTargetConfigurations = exports.readProjectConfigurationsFromRootMap = exports.createProjectConfigurations = exports.mergeMetadata = exports.mergeProjectConfigurationIntoRootMap = void 0;
 const logger_1 = require("../../utils/logger");
 const fileutils_1 = require("../../utils/fileutils");
 const workspace_root_1 = require("../../utils/workspace-root");
@@ -12,17 +12,17 @@ const error_types_1 = require("../error-types");
 function mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInformation, 
 // This function is used when reading project configuration
 // in generators, where we don't want to do this.
-skipCommandNormalization) {
+skipTargetNormalization) {
     if (configurationSourceMaps && !configurationSourceMaps[project.root]) {
         configurationSourceMaps[project.root] = {};
     }
     const sourceMap = configurationSourceMaps?.[project.root];
-    let matchingProject = projectRootMap.get(project.root);
+    let matchingProject = projectRootMap[project.root];
     if (!matchingProject) {
-        projectRootMap.set(project.root, {
+        projectRootMap[project.root] = {
             root: project.root,
-        });
-        matchingProject = projectRootMap.get(project.root);
+        };
+        matchingProject = projectRootMap[project.root];
         if (sourceMap) {
             sourceMap[`root`] = sourceInformation;
         }
@@ -129,16 +129,18 @@ skipCommandNormalization) {
                 !matchingProject.targets?.[targetName]) {
                 continue;
             }
-            const mergedTarget = mergeTargetConfigurations(skipCommandNormalization
+            const normalizedTarget = skipTargetNormalization
                 ? target
-                : resolveCommandSyntacticSugar(target, project.root), matchingProject.targets?.[targetName], sourceMap, sourceInformation, `targets.${targetName}`);
+                : normalizeTarget(target, project);
+            const mergedTarget = mergeTargetConfigurations(normalizedTarget, matchingProject.targets?.[targetName], sourceMap, sourceInformation, `targets.${targetName}`);
             // We don't want the symbol to live on past the merge process
             if (mergedTarget?.[symbols_1.ONLY_MODIFIES_EXISTING_TARGET])
                 delete mergedTarget?.[symbols_1.ONLY_MODIFIES_EXISTING_TARGET];
             updatedProjectConfiguration.targets[targetName] = mergedTarget;
         }
     }
-    projectRootMap.set(updatedProjectConfiguration.root, updatedProjectConfiguration);
+    projectRootMap[updatedProjectConfiguration.root] =
+        updatedProjectConfiguration;
 }
 exports.mergeProjectConfigurationIntoRootMap = mergeProjectConfigurationIntoRootMap;
 function mergeMetadata(sourceMap, sourceInformation, baseSourceMapPath, metadata, matchingMetadata) {
@@ -210,6 +212,7 @@ function mergeMetadata(sourceMap, sourceInformation, baseSourceMapPath, metadata
     }
     return result;
 }
+exports.mergeMetadata = mergeMetadata;
 /**
  * Transforms a list of project paths into a map of project configurations.
  *
@@ -264,7 +267,7 @@ plugins) {
     }
     return Promise.all(results).then((results) => {
         perf_hooks_1.performance.mark('createNodes:merge - start');
-        const projectRootMap = new Map();
+        const projectRootMap = {};
         const externalNodes = {};
         const configurationSourceMaps = {};
         for (const result of results.flat()) {
@@ -291,14 +294,17 @@ plugins) {
             }
             Object.assign(externalNodes, pluginExternalNodes);
         }
-        let projects;
         try {
-            projects = readProjectConfigurationsFromRootMap(projectRootMap);
+            // We still call this just to assert that the root map
+            // only contains valid project names. This is a safety check.
+            //
+            // The signature itself can't be changed as we need it to return
+            // project configurations for use in devkit.
+            readProjectConfigurationsFromRootMap(projectRootMap);
         }
         catch (e) {
             if ((0, error_types_1.isProjectsWithNoNameError)(e) ||
                 (0, error_types_1.isProjectsWithConflictingNamesError)(e)) {
-                projects = e.projects;
                 errors.push(e);
             }
             else {
@@ -312,18 +318,20 @@ plugins) {
         perf_hooks_1.performance.measure('build-project-configs', 'build-project-configs:start', 'build-project-configs:end');
         if (errors.length === 0) {
             return {
-                projects,
+                projects: projectRootMap,
                 externalNodes,
                 projectRootMap: rootMap,
                 sourceMaps: configurationSourceMaps,
+                matchingProjectFiles: projectFiles,
             };
         }
         else {
             throw new error_types_1.ProjectConfigurationsError(errors, {
-                projects,
+                projects: projectRootMap,
                 externalNodes,
                 projectRootMap: rootMap,
                 sourceMaps: configurationSourceMaps,
+                matchingProjectFiles: projectFiles,
             });
         }
     });
@@ -336,7 +344,8 @@ function readProjectConfigurationsFromRootMap(projectRootMap) {
     // to provide better error messaging.
     const conflicts = new Map();
     const projectRootsWithNoName = [];
-    for (const [root, configuration] of projectRootMap.entries()) {
+    for (const root in projectRootMap) {
+        const configuration = projectRootMap[root];
         // We're setting `// targets` as a comment `targets` is empty due to Project Crystal.
         // Strip it before returning configuration for usage.
         if (configuration['// targets'])
@@ -344,6 +353,9 @@ function readProjectConfigurationsFromRootMap(projectRootMap) {
         if (!configuration.name) {
             try {
                 const { name } = (0, fileutils_1.readJsonFile)((0, path_1.join)(root, 'package.json'));
+                if (!name) {
+                    throw new Error("No name found for project at '" + root + "'.");
+                }
                 configuration.name = name;
             }
             catch {
@@ -388,7 +400,7 @@ function mergeTargetConfigurations(target, baseTarget, projectConfigSourceMap, s
     const { configurations: defaultConfigurations, options: defaultOptions, ...baseTargetProperties } = baseTarget ?? {};
     // Target is "compatible", e.g. executor is defined only once or is the same
     // in both places. This means that it is likely safe to merge
-    const isCompatible = isCompatibleTarget(baseTargetProperties, target);
+    const isCompatible = isCompatibleTarget(baseTarget ?? {}, target);
     // If the targets are not compatible, we would normally overwrite the old target
     // with the new one. However, we have a special case for targets that have the
     // ONLY_MODIFIES_EXISTING_TARGET symbol set. This prevents the merged target
@@ -451,8 +463,8 @@ function isCompatibleTarget(a, b) {
         return false;
     const isRunCommands = a.executor === 'nx:run-commands';
     if (isRunCommands) {
-        const aCommand = a.options?.command ?? a.options?.commands.join(' && ');
-        const bCommand = b.options?.command ?? b.options?.commands.join(' && ');
+        const aCommand = a.options?.command ?? a.options?.commands?.join(' && ');
+        const bCommand = b.options?.command ?? b.options?.commands?.join(' && ');
         const oneHasNoCommand = !aCommand || !bCommand;
         const hasSameCommand = aCommand === bCommand;
         return oneHasNoCommand || hasSameCommand;
@@ -544,7 +556,8 @@ function readTargetDefaultsForTarget(targetName, targetDefaults, executor) {
 exports.readTargetDefaultsForTarget = readTargetDefaultsForTarget;
 function createRootMap(projectRootMap) {
     const map = {};
-    for (const [projectRoot, { name: projectName }] of projectRootMap) {
+    for (const projectRoot in projectRootMap) {
+        const projectName = projectRootMap[projectRoot].name;
         map[projectRoot] = projectName;
     }
     return map;
@@ -568,3 +581,13 @@ function resolveCommandSyntacticSugar(target, key) {
         };
     }
 }
+function normalizeTarget(target, project) {
+    target = resolveCommandSyntacticSugar(target, project.root);
+    target.options = resolveNxTokensInOptions(target.options, project, `${project.root}:${target}`);
+    target.configurations ??= {};
+    for (const configuration in target.configurations) {
+        target.configurations[configuration] = resolveNxTokensInOptions(target.configurations[configuration], project, `${project.root}:${target}:${configuration}`);
+    }
+    return target;
+}
+exports.normalizeTarget = normalizeTarget;

package/src/tasks-runner/create-task-graph.js

@@ -170,7 +170,6 @@ class ProcessTasks {
             projectRoot: project.data.root,
             overrides: interpolatedOverrides,
             outputs: (0, utils_1.getOutputs)(this.projectGraph.nodes, qualifiedTarget, interpolatedOverrides),
-            // TODO(v19): Remove cast here after typing is moved back onto TargetConfiguration
             cache: project.data.targets[target].cache,
         };
     }

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

@@ -24,6 +24,10 @@ const EXTENDED_LEFT_PAD = `      `;
  */
 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();
@@ -261,7 +265,7 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
                 '',
                 `${failedTasksForPrinting
                     .map((t) => `${EXTENDED_LEFT_PAD}${output_1.output.colors.red('-')} ${output_1.output.formatCommand(t.toString())}`)
-                    .join('\n ')}`,
+                    .join('\n')}`,
             ];
             if (failedTasks.size > numFailedToPrint) {
                 failureSummaryRows.push(output_1.output.dim(`${EXTENDED_LEFT_PAD}...and ${failedTasks.size - numFailedToPrint} more...`));

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

@@ -24,6 +24,10 @@ const EXTENDED_LEFT_PAD = `      `;
  */
 async function createRunOneDynamicOutputRenderer({ initiatingProject, 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();

package/src/tasks-runner/pseudo-terminal.d.ts

@@ -11,10 +11,11 @@ export declare class PseudoTerminal {
     static isSupported(): boolean;
     constructor(rustPseudoTerminal: RustPseudoTerminal);
     init(): Promise<void>;
-    runCommand(command: string, { cwd, jsEnv, quiet, }?: {
+    runCommand(command: string, { cwd, jsEnv, quiet, tty, }?: {
         cwd?: string;
         jsEnv?: Record<string, string>;
         quiet?: boolean;
+        tty?: boolean;
     }): PseudoTtyProcess;
     fork(id: string, script: string, { cwd, jsEnv, quiet, }: {
         cwd?: string;

package/src/tasks-runner/pseudo-terminal.js

@@ -32,8 +32,8 @@ class PseudoTerminal {
         await this.pseudoIPC.init();
         this.initialized = true;
     }
-    runCommand(command, { cwd, jsEnv, quiet, } = {}) {
-        return new PseudoTtyProcess(this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, quiet));
+    runCommand(command, { cwd, jsEnv, quiet, tty, } = {}) {
+        return new PseudoTtyProcess(this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, quiet, tty));
     }
     async fork(id, script, { cwd, jsEnv, quiet, }) {
         if (!this.initialized) {
@@ -142,6 +142,12 @@ function supportedPtyPlatform() {
     if (process.platform !== 'win32') {
         return true;
     }
+    // TODO: Re-enable Windows support when it's stable
+    // Currently, there's an issue with control chars.
+    // See: https://github.com/nrwl/nx/issues/22358
+    if (process.env.NX_WINDOWS_PTY_SUPPORT !== 'true') {
+        return false;
+    }
     let windowsVersion = os.release().split('.');
     let windowsBuild = windowsVersion[2];
     if (!windowsBuild) {