nx 18.2.0-canary.20240319-55f31cf → 18.2.0-canary.20240320-64b2396

package/src/executors/run-commands/run-commands.impl.js

@@ -267,7 +267,11 @@ function processEnv(color, cwd, env) {
         ...localEnv,
         ...env,
     };
-    res.PATH = localEnv.PATH; // need to override PATH to make sure we are using the local node_modules
+    // need to override PATH to make sure we are using the local node_modules
+    if (localEnv.PATH)
+        res.PATH = localEnv.PATH; // UNIX-like
+    if (localEnv.Path)
+        res.Path = localEnv.Path; // Windows
     if (color) {
         res.FORCE_COLOR = `${color}`;
     }

package/src/plugins/js/versions.d.ts

@@ -1 +1 @@
-export declare const typescriptVersion = "~5.3.2";
+export declare const typescriptVersion = "~5.4.2";

package/src/plugins/js/versions.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.typescriptVersion = void 0;
-exports.typescriptVersion = '~5.3.2';
+exports.typescriptVersion = '~5.4.2';

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

@@ -32,17 +32,27 @@ skipCommandNormalization) {
     // a project.json in which case it was already updated above.
     const updatedProjectConfiguration = {
         ...matchingProject,
-        ...project,
     };
-    if (sourceMap) {
-        for (const property in project) {
-            sourceMap[`${property}`] = sourceInformation;
+    for (const k in project) {
+        if (![
+            'tags',
+            'implicitDependencies',
+            'generators',
+            'targets',
+            'metadata',
+            'namedInputs',
+        ].includes(k)) {
+            updatedProjectConfiguration[k] = project[k];
+            if (sourceMap) {
+                sourceMap[`${k}`] = sourceInformation;
+            }
         }
     }
     // The next blocks handle properties that should be themselves merged (e.g. targets, tags, and implicit dependencies)
     if (project.tags) {
         updatedProjectConfiguration.tags = Array.from(new Set((matchingProject.tags ?? []).concat(project.tags)));
         if (sourceMap) {
+            sourceMap['tags'] ??= sourceInformation;
             project.tags.forEach((tag) => {
                 sourceMap[`tags.${tag}`] = sourceInformation;
             });
@@ -51,6 +61,7 @@ skipCommandNormalization) {
     if (project.implicitDependencies) {
         updatedProjectConfiguration.implicitDependencies = (matchingProject.implicitDependencies ?? []).concat(project.implicitDependencies);
         if (sourceMap) {
+            sourceMap['implicitDependencies'] ??= sourceInformation;
             project.implicitDependencies.forEach((implicitDependency) => {
                 sourceMap[`implicitDependencies.${implicitDependency}`] =
                     sourceInformation;
@@ -61,6 +72,7 @@ skipCommandNormalization) {
         // Start with generators config in new project.
         updatedProjectConfiguration.generators = { ...project.generators };
         if (sourceMap) {
+            sourceMap['generators'] ??= sourceInformation;
             for (const generator in project.generators) {
                 sourceMap[`generators.${generator}`] = sourceInformation;
                 for (const property in project.generators[generator]) {
@@ -85,6 +97,7 @@ skipCommandNormalization) {
             ...project.namedInputs,
         };
         if (sourceMap) {
+            sourceMap['namedInputs'] ??= sourceInformation;
             for (const namedInput in project.namedInputs) {
                 sourceMap[`namedInputs.${namedInput}`] = sourceInformation;
             }
@@ -94,6 +107,9 @@ skipCommandNormalization) {
         // We merge the targets with special handling, so clear this back to the
         // targets as defined originally before merging.
         updatedProjectConfiguration.targets = matchingProject?.targets ?? {};
+        if (sourceMap) {
+            sourceMap['targets'] ??= sourceInformation;
+        }
         // For each target defined in the new config
         for (const targetName in project.targets) {
             // Always set source map info for the target, but don't overwrite info already there
@@ -117,6 +133,75 @@ skipCommandNormalization) {
             updatedProjectConfiguration.targets[targetName] = mergedTarget;
         }
     }
+    if (project.metadata) {
+        if (sourceMap) {
+            sourceMap['targets'] ??= sourceInformation;
+        }
+        for (const [metadataKey, value] of Object.entries({
+            ...project.metadata,
+        })) {
+            const existingValue = matchingProject.metadata?.[metadataKey];
+            if (Array.isArray(value) && Array.isArray(existingValue)) {
+                for (const item of [...value]) {
+                    const newLength = updatedProjectConfiguration.metadata[metadataKey].push(item);
+                    if (sourceMap) {
+                        sourceMap[`metadata.${metadataKey}.${newLength - 1}`] =
+                            sourceInformation;
+                    }
+                }
+            }
+            else if (Array.isArray(value) && existingValue === undefined) {
+                updatedProjectConfiguration.metadata ??= {};
+                updatedProjectConfiguration.metadata[metadataKey] ??= value;
+                if (sourceMap) {
+                    sourceMap[`metadata.${metadataKey}`] = sourceInformation;
+                }
+                for (let i = 0; i < value.length; i++) {
+                    if (sourceMap) {
+                        sourceMap[`metadata.${metadataKey}.${i}`] = sourceInformation;
+                    }
+                }
+            }
+            else if (typeof value === 'object' &&
+                typeof existingValue === 'object') {
+                for (const key in value) {
+                    const existingValue = matchingProject.metadata?.[metadataKey]?.[key];
+                    if (Array.isArray(value[key]) && Array.isArray(existingValue)) {
+                        for (const item of value[key]) {
+                            const i = updatedProjectConfiguration.metadata[metadataKey][key].push(item);
+                            if (sourceMap) {
+                                sourceMap[`metadata.${metadataKey}.${key}.${i - 1}`] =
+                                    sourceInformation;
+                            }
+                        }
+                    }
+                    else {
+                        updatedProjectConfiguration.metadata[metadataKey] = value;
+                        if (sourceMap) {
+                            sourceMap[`metadata.${metadataKey}`] = sourceInformation;
+                        }
+                    }
+                }
+            }
+            else {
+                updatedProjectConfiguration.metadata[metadataKey] = value;
+                if (sourceMap) {
+                    sourceMap[`metadata.${metadataKey}`] = sourceInformation;
+                    if (typeof value === 'object') {
+                        for (const k in value) {
+                            sourceMap[`metadata.${metadataKey}.${k}`] = sourceInformation;
+                            if (Array.isArray(value[k])) {
+                                for (let i = 0; i < value[k].length; i++) {
+                                    sourceMap[`metadata.${metadataKey}.${k}.${i}`] =
+                                        sourceInformation;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
     projectRootMap.set(updatedProjectConfiguration.root, updatedProjectConfiguration);
 }
 exports.mergeProjectConfigurationIntoRootMap = mergeProjectConfigurationIntoRootMap;