@depup/nx 22.6.1-depup.0 → 22.6.2-depup.0

package/src/project-graph/utils/project-configuration/name-substitution-manager.js

@@ -17,25 +17,24 @@ const minimatch_1 = require("minimatch");
  * hold a stale reference to the now-nonexistent name `B`.
  *
  * This class solves that by:
- * 1. Scanning each plugin's results for project-name references in
+ * 1. Receiving a live nameMap accessor (maintained by ProjectNodesManager)
+ *    for name → root resolution and colon-delimited string parsing.
+ * 2. Tracking dirty roots via {@link identifyProjectWithRoot} when a
+ *    project name changes at a root.
+ * 3. Scanning each plugin's results for project-name references in
  *    `inputs` and `dependsOn` ({@link registerSubstitutorsForNodeResults}).
- *    Substitutors are indexed by the **referenced name as it appeared in
- *    the plugin result** — no lookup into any project map is needed at
- *    registration time.
- * 2. When a project's name changes during the merge, recording that change
- *    via {@link markDirty} so substitutors for the old name can be located.
- * 3. After all results are merged, applying the substitutors for every
+ * 4. After all results are merged, applying the substitutors for every
  *    renamed project so that references are updated to the final name
  *    ({@link applySubstitutions}).
  */
 class ProjectNameInNodePropsManager {
-    constructor() {
-        // Maps the *referenced project name at registration time* → set of
-        // substitutor entries that should run when a project is renamed FROM
-        // that name. Keying by name (not root) means no project-map lookup is
-        // needed at registration time, and ordering between result entries does
-        // not matter.
-        this.projectNameSubstitutors = new Map();
+    constructor(getNameMap) {
+        // Maps the *root of the referenced project* → set of substitutor entries
+        // that should run when that project is renamed. Keying by root (not name)
+        // ensures that when project "A" is renamed to "B" and a *new* project
+        // takes the name "A" at a different root, references to the new "A" are
+        // not incorrectly rewritten.
+        this.substitutorsByReferencedRoot = new Map();
         // Tracks substitutor entries by (array path, index, subIndex). This
         // serves two purposes:
         //
@@ -50,25 +49,32 @@ class ProjectNameInNodePropsManager {
         // Inner array: indexed by position; each slot holds an array so that a
         //   single `projects` array can hold multiple name references.
         this.substitutorsByArrayKey = new Map();
-        // Projects whose names changed during the merge phase. Key = root of the
-        // renamed project, value = all names it previously held in this merge.
-        // These are used in applySubstitutions to locate substitutors keyed by
-        // old names.
-        this.dirtyEntries = new Map();
-        // Partial project graph nodes accumulated across plugin registrations.
-        // Used by splitTargetFromNodes to properly parse string-form dependsOn
-        // entries like "project:target" — including project / target names that
-        // contain colons.
-        this.knownProjectNodes = {};
+        // Holds substitutors for project names that haven't been identified yet
+        // (forward references). When identifyProjectWithRoot is later called for
+        // a name in this map, the entries are promoted to substitutorsByReferencedRoot.
+        this.pendingSubstitutorsByName = new Map();
+        // Roots of projects whose names changed during the merge phase.
+        this.dirtyRoots = new Set();
+        this.getNameMap = getNameMap ?? (() => ({}));
     }
     removeSubstitutorEntry(item) {
-        const substitutors = this.projectNameSubstitutors.get(item.referencedName);
-        if (!substitutors) {
-            return;
+        if (item.referencedRoot !== undefined) {
+            const substitutors = this.substitutorsByReferencedRoot.get(item.referencedRoot);
+            if (substitutors) {
+                substitutors.delete(item.entry);
+                if (substitutors.size === 0) {
+                    this.substitutorsByReferencedRoot.delete(item.referencedRoot);
+                }
+            }
         }
-        substitutors.delete(item.entry);
-        if (substitutors.size === 0) {
-            this.projectNameSubstitutors.delete(item.referencedName);
+        if (item.referencedName !== undefined) {
+            const substitutors = this.pendingSubstitutorsByName.get(item.referencedName);
+            if (substitutors) {
+                substitutors.delete(item.entry);
+                if (substitutors.size === 0) {
+                    this.pendingSubstitutorsByName.delete(item.referencedName);
+                }
+            }
         }
     }
     // Removes the substitutor registered at the given index (and optional
@@ -165,35 +171,51 @@ class ProjectNameInNodePropsManager {
             callback(targetConfig);
         }
     }
-    // Registers a new substitutor keyed by `referencedName` (the project name
-    // as it appears in the reference), tracked at (arrayKey, index, subIndex)
-    // for deduplication and tail-clearing.
+    // Registers a new substitutor for `referencedName`, tracked at
+    // (arrayKey, index, subIndex) for deduplication and tail-clearing.
+    // The substitutor is keyed by root when the referenced project is
+    // already in the nameMap, otherwise parked in pendingSubstitutorsByName.
     registerProjectNameSubstitutor(referencedName, ownerRoot, arrayKey, index, substitutor, subIndex) {
         // Evict any existing substitutor at this exact position first.
         this.clearSubstitutorAtIndex(arrayKey, index, subIndex);
-        let substitutorsForName = this.projectNameSubstitutors.get(referencedName);
-        if (!substitutorsForName) {
-            substitutorsForName = new Set();
-            this.projectNameSubstitutors.set(referencedName, substitutorsForName);
-        }
         const entry = { ownerRoot, substitutor };
-        substitutorsForName.add(entry);
+        const nameMap = this.getNameMap();
+        const referencedRoot = nameMap[referencedName]?.root;
+        let trackingItem;
+        if (referencedRoot !== undefined) {
+            // Project is already known — key directly by root.
+            let substitutorsForRoot = this.substitutorsByReferencedRoot.get(referencedRoot);
+            if (!substitutorsForRoot) {
+                substitutorsForRoot = new Set();
+                this.substitutorsByReferencedRoot.set(referencedRoot, substitutorsForRoot);
+            }
+            substitutorsForRoot.add(entry);
+            trackingItem = { referencedRoot, entry };
+        }
+        else {
+            // Forward reference — park in pending map keyed by name.
+            let pendingSet = this.pendingSubstitutorsByName.get(referencedName);
+            if (!pendingSet) {
+                pendingSet = new Set();
+                this.pendingSubstitutorsByName.set(referencedName, pendingSet);
+            }
+            pendingSet.add(entry);
+            trackingItem = { referencedName, entry };
+        }
         let byIndex = this.substitutorsByArrayKey.get(arrayKey);
         if (!byIndex) {
             byIndex = [];
             this.substitutorsByArrayKey.set(arrayKey, byIndex);
         }
         if (subIndex === undefined) {
-            // Single project reference — store directly
-            byIndex[index] = [{ referencedName, entry }];
+            byIndex[index] = [trackingItem];
         }
         else {
-            // Multiple projects in an array — ensure the slot exists
             if (!byIndex[index]) {
                 byIndex[index] = [];
             }
             const subArray = byIndex[index];
-            subArray[subIndex] = { referencedName, entry };
+            subArray[subIndex] = trackingItem;
         }
     }
     /**
@@ -201,10 +223,9 @@ class ProjectNameInNodePropsManager {
      * reference another project by name, and registers substitutors so those
      * references are updated if the target project is later renamed.
      *
-     * Project nodes from each call are accumulated internally so that
-     * string-form `dependsOn` entries (e.g. `"project:target"`) can be
-     * properly parsed with {@link splitTargetFromNodes}, even when project
-     * or target names contain colons.
+     * **Important**: call {@link identifyProjectWithRoot} for all projects in
+     * this result (and all prior results) before calling this method, so that
+     * referenced project names can be resolved to roots.
      *
      * @param pluginResultProjects Projects from a single plugin's createNodes call.
      */
@@ -212,18 +233,6 @@ class ProjectNameInNodePropsManager {
         if (!pluginResultProjects) {
             return;
         }
-        // Accumulate partial project graph nodes for splitTargetFromNodes.
-        for (const root in pluginResultProjects) {
-            const project = pluginResultProjects[root];
-            const name = project.name;
-            if (name) {
-                this.knownProjectNodes[name] = {
-                    type: 'lib',
-                    name,
-                    data: { root, ...project },
-                };
-            }
-        }
         for (const ownerRoot in pluginResultProjects) {
             const project = pluginResultProjects[ownerRoot];
             if (!project.targets) {
@@ -238,7 +247,7 @@ class ProjectNameInNodePropsManager {
                     this.registerSubstitutorsForInputs(ownerRoot, targetName, targetConfig.inputs);
                 }
                 if (Array.isArray(targetConfig.dependsOn)) {
-                    this.registerSubstitutorsForDependsOn(ownerRoot, targetName, targetConfig.dependsOn);
+                    this.registerSubstitutorsForDependsOn(ownerRoot, targetName, targetConfig.dependsOn, project.targets, project.name);
                 }
             }
         }
@@ -335,17 +344,21 @@ class ProjectNameInNodePropsManager {
         // the array may have shrunk compared to a previous plugin's contribution.
         this.clearSubstitutorsFromIndex(arrayKey, inputs.length);
     }
-    registerSubstitutorsForDependsOn(ownerRoot, targetName, dependsOn) {
+    registerSubstitutorsForDependsOn(ownerRoot, targetName, dependsOn, ownerTargets, ownerProjectName) {
         const arrayKey = `${ownerRoot}:targets.${targetName}.dependsOn`;
         for (let i = 0; i < dependsOn.length; i++) {
             const dep = dependsOn[i];
             if (typeof dep === 'string') {
                 // String-form dependsOn entries like "project:target". Strings
                 // starting with '^' are dependency-mode references (no project
-                // name). Use splitTargetFromNodes with accumulated project nodes
-                // to properly handle project / target names containing colons.
-                if (!dep.startsWith('^')) {
-                    const [maybeProject, ...rest] = (0, split_target_1.splitTargetFromNodes)(dep, this.knownProjectNodes);
+                // name). Use splitTargetFromConfigurations with the nameMap to
+                // properly handle project / target names containing colons.
+                //
+                // However, if the string matches a target name in the owning
+                // project, it is a same-project target reference (e.g. a target
+                // literally named "nx:echo"), not a cross-project reference.
+                if (!dep.startsWith('^') && !(ownerTargets && dep in ownerTargets)) {
+                    const [maybeProject, ...rest] = (0, split_target_1.splitTargetFromConfigurations)(dep, this.getNameMap(), { silent: true, currentProject: ownerProjectName });
                     if (rest.length > 0) {
                         const targetPart = rest.join(':');
                         this.registerProjectNameSubstitutor(maybeProject, ownerRoot, arrayKey, i, this.createDependsOnTargetStringSubstitutor(targetName, i, targetPart));
@@ -384,17 +397,50 @@ class ProjectNameInNodePropsManager {
         this.clearSubstitutorsFromIndex(arrayKey, dependsOn.length);
     }
     /**
-     * Records that the project at `root` was renamed from `previousName`.
-     * Substitutors registered for `previousName` will fire during
-     * {@link applySubstitutions}.
+     * Records that a project with `name` exists at the given `root`. Call
+     * this during the merge phase whenever a project's name changes at a
+     * root — **before** calling
+     * {@link registerSubstitutorsForNodeResults} for that result.
+     *
+     * The nameMap (maintained externally by ProjectNodesManager) is always
+     * current — this method only needs to mark the root as dirty and
+     * promote any pending substitutors keyed by name.
      */
-    markDirty(root, previousName) {
-        let previousNames = this.dirtyEntries.get(root);
-        if (!previousNames) {
-            previousNames = new Set();
-            this.dirtyEntries.set(root, previousNames);
+    identifyProjectWithRoot(root, name) {
+        // Always mark dirty when called — the caller only invokes this when
+        // the name actually changed at this root (first identification or
+        // rename). If there are pending substitutors for this name, those
+        // forward refs need updating. If it's a rename, existing refs need
+        // updating. Either way, the root is dirty.
+        this.dirtyRoots.add(root);
+        // Promote any pending substitutors that were waiting for this name.
+        const pending = this.pendingSubstitutorsByName.get(name);
+        if (pending) {
+            this.pendingSubstitutorsByName.delete(name);
+            let substitutorsForRoot = this.substitutorsByReferencedRoot.get(root);
+            if (!substitutorsForRoot) {
+                substitutorsForRoot = new Set();
+                this.substitutorsByReferencedRoot.set(root, substitutorsForRoot);
+            }
+            for (const entry of pending) {
+                substitutorsForRoot.add(entry);
+            }
+            // Update tracking items to reflect the promotion from name → root.
+            for (const [, byIndex] of this.substitutorsByArrayKey) {
+                for (const atIndex of byIndex) {
+                    if (!atIndex)
+                        continue;
+                    for (const item of atIndex) {
+                        if (item &&
+                            item.referencedName === name &&
+                            pending.has(item.entry)) {
+                            item.referencedName = undefined;
+                            item.referencedRoot = root;
+                        }
+                    }
+                }
+            }
         }
-        previousNames.add(previousName);
     }
     /**
      * Executes all registered substitutors for renamed projects, updating
@@ -402,23 +448,19 @@ class ProjectNameInNodePropsManager {
      * called once after all plugin results have been merged.
      */
     applySubstitutions(rootMap) {
-        for (const [root, previousNames] of this.dirtyEntries) {
+        for (const root of this.dirtyRoots) {
             const finalName = rootMap[root]?.name;
             if (!finalName) {
                 continue;
             }
-            for (const previousName of previousNames) {
-                const substitutors = this.projectNameSubstitutors.get(previousName);
-                if (!substitutors) {
-                    continue;
-                }
-                for (const { ownerRoot, substitutor } of substitutors) {
-                    // Each entry stores the ownerRoot of the project holding the stale
-                    // reference so we can look up its final merged config here.
-                    const ownerConfig = rootMap[ownerRoot];
-                    if (ownerConfig) {
-                        substitutor(finalName, ownerConfig);
-                    }
+            const substitutors = this.substitutorsByReferencedRoot.get(root);
+            if (!substitutors) {
+                continue;
+            }
+            for (const { ownerRoot, substitutor } of substitutors) {
+                const ownerConfig = rootMap[ownerRoot];
+                if (ownerConfig) {
+                    substitutor(finalName, ownerConfig);
                 }
             }
         }

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

@@ -0,0 +1,40 @@
+import { ProjectConfiguration } from '../../../config/workspace-json-project-json';
+import type { ConfigurationSourceMaps, SourceInformation } from './source-maps';
+export { validateProject } from './target-normalization';
+export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Record<string, ProjectConfiguration>, project: ProjectConfiguration, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation, skipTargetNormalization?: boolean): {
+    nameChanged: boolean;
+};
+export declare function readProjectConfigurationsFromRootMap(projectRootMap: Record<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
+export declare function createRootMap(projectRootMap: Record<string, ProjectConfiguration>): Record<string, string>;
+/**
+ * Owns the rootMap (root → ProjectConfiguration) and nameMap
+ * (name → ProjectConfiguration), coordinating merges with the
+ * {@link ProjectNameInNodePropsManager} for deferred name substitutions.
+ *
+ * The nameMap entries are the *same object references* as the rootMap
+ * entries, so when a merge adds targets to a rootMap entry the nameMap
+ * entry automatically has them too — no copying, no staleness.
+ */
+export declare class ProjectNodesManager {
+    private rootMap;
+    private nameMap;
+    private nameSubstitutionManager;
+    constructor();
+    getRootMap(): Record<string, ProjectConfiguration>;
+    /**
+     * Merges a project into the rootMap, updates the nameMap, and notifies
+     * the substitution manager if the name changed at this root.
+     */
+    mergeProjectNode(project: ProjectConfiguration, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation): void;
+    /**
+     * Registers substitutors for a plugin result's project references
+     * in `inputs` and `dependsOn`.
+     */
+    registerSubstitutors(pluginResultProjects?: Record<string, Omit<ProjectConfiguration, 'root'> & Partial<ProjectConfiguration>>): void;
+    /**
+     * Applies all pending name substitutions. Call once after all plugin
+     * results have been merged.
+     */
+    applySubstitutions(): void;
+}
+//# sourceMappingURL=project-nodes-manager.d.ts.map

package/src/project-graph/utils/project-configuration/project-nodes-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-nodes-manager.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/project-graph/utils/project-configuration/project-nodes-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6CAA6C,CAAC;AAcnF,OAAO,KAAK,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAMhF,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,wBAAgB,oCAAoC,CAClD,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,EACpD,OAAO,EAAE,oBAAoB,EAC7B,uBAAuB,CAAC,EAAE,uBAAuB,EACjD,iBAAiB,CAAC,EAAE,iBAAiB,EAGrC,uBAAuB,CAAC,EAAE,OAAO,GAChC;IACD,WAAW,EAAE,OAAO,CAAC;CACtB,CAqLA;AAED,wBAAgB,oCAAoC,CAClD,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,wCAwCrD;AAED,wBAAgB,aAAa,CAC3B,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,0BAQrD;AAED;;;;;;;;GAQG;AACH,qBAAa,mBAAmB;IAE9B,OAAO,CAAC,OAAO,CAA4C;IAE3D,OAAO,CAAC,OAAO,CAA4C;IAC3D,OAAO,CAAC,uBAAuB,CAAgC;;IAU/D,UAAU,IAAI,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC;IAIlD;;;OAGG;IACH,gBAAgB,CACd,OAAO,EAAE,oBAAoB,EAC7B,uBAAuB,CAAC,EAAE,uBAAuB,EACjD,iBAAiB,CAAC,EAAE,iBAAiB,GACpC,IAAI;IA+BP;;;OAGG;IACH,oBAAoB,CAClB,oBAAoB,CAAC,EAAE,MAAM,CAC3B,MAAM,EACN,IAAI,CAAC,oBAAoB,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CACnE,GACA,IAAI;IAMP;;;OAGG;IACH,kBAAkB,IAAI,IAAI;CAG3B"}

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

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectNodesManager = exports.validateProject = void 0;
+exports.mergeProjectConfigurationIntoRootMap = mergeProjectConfigurationIntoRootMap;
+exports.readProjectConfigurationsFromRootMap = readProjectConfigurationsFromRootMap;
+exports.createRootMap = createRootMap;
+const error_types_1 = require("../../error-types");
+const target_merging_1 = require("./target-merging");
+const target_normalization_1 = require("./target-normalization");
+const name_substitution_manager_1 = require("./name-substitution-manager");
+const source_maps_1 = require("./source-maps");
+const minimatch_1 = require("minimatch");
+const globs_1 = require("../../../utils/globs");
+var target_normalization_2 = require("./target-normalization");
+Object.defineProperty(exports, "validateProject", { enumerable: true, get: function () { return target_normalization_2.validateProject; } });
+function mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInformation, 
+// This function is used when reading project configuration
+// in generators, where we don't want to do this.
+skipTargetNormalization) {
+    project.root = project.root === '' ? '.' : project.root;
+    if (configurationSourceMaps && !configurationSourceMaps[project.root]) {
+        configurationSourceMaps[project.root] = {};
+    }
+    const sourceMap = configurationSourceMaps?.[project.root];
+    let matchingProject = projectRootMap[project.root];
+    if (!matchingProject) {
+        projectRootMap[project.root] = {
+            root: project.root,
+        };
+        matchingProject = projectRootMap[project.root];
+        if (sourceMap) {
+            sourceMap[`root`] = sourceInformation;
+        }
+    }
+    // This handles top level properties that are overwritten.
+    // e.g. `srcRoot`, `projectType`, or other fields that shouldn't be extended
+    // Note: `name` is set specifically here to keep it from changing. The name is
+    // always determined by the first inference plugin to ID a project, unless it has
+    // a project.json in which case it was already updated above.
+    const updatedProjectConfiguration = {
+        ...matchingProject,
+    };
+    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;
+            });
+        }
+    }
+    if (project.implicitDependencies) {
+        updatedProjectConfiguration.implicitDependencies = (matchingProject.implicitDependencies ?? []).concat(project.implicitDependencies);
+        if (sourceMap) {
+            sourceMap['implicitDependencies'] ??= sourceInformation;
+            project.implicitDependencies.forEach((implicitDependency) => {
+                sourceMap[`implicitDependencies.${implicitDependency}`] =
+                    sourceInformation;
+            });
+        }
+    }
+    if (project.generators) {
+        // 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]) {
+                    sourceMap[`generators.${generator}.${property}`] = sourceInformation;
+                }
+            }
+        }
+        if (matchingProject.generators) {
+            // For each generator that was already defined, shallow merge the options.
+            // Project contains the new info, so it has higher priority.
+            for (const generator in matchingProject.generators) {
+                updatedProjectConfiguration.generators[generator] = {
+                    ...matchingProject.generators[generator],
+                    ...project.generators[generator],
+                };
+            }
+        }
+    }
+    if (project.namedInputs) {
+        updatedProjectConfiguration.namedInputs = {
+            ...matchingProject.namedInputs,
+            ...project.namedInputs,
+        };
+        if (sourceMap) {
+            sourceMap['namedInputs'] ??= sourceInformation;
+            for (const namedInput in project.namedInputs) {
+                sourceMap[`namedInputs.${namedInput}`] = sourceInformation;
+            }
+        }
+    }
+    if (project.metadata) {
+        updatedProjectConfiguration.metadata = (0, target_merging_1.mergeMetadata)(sourceMap, sourceInformation, 'metadata', project.metadata, matchingProject.metadata);
+    }
+    if (project.targets) {
+        // 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
+            // if augmenting an existing target.
+            const target = project.targets?.[targetName];
+            if (sourceMap) {
+                sourceMap[(0, source_maps_1.targetSourceMapKey)(targetName)] = sourceInformation;
+            }
+            const normalizedTarget = skipTargetNormalization
+                ? target
+                : (0, target_merging_1.resolveCommandSyntacticSugar)(target, project.root);
+            let matchingTargets = [];
+            if ((0, globs_1.isGlobPattern)(targetName)) {
+                // find all targets matching the glob pattern
+                // this will map atomized targets to the glob pattern same as it does for targetDefaults
+                matchingTargets = Object.keys(updatedProjectConfiguration.targets).filter((key) => (0, minimatch_1.minimatch)(key, targetName));
+            }
+            // If no matching targets were found, we can assume that the target name is not (meant to be) a glob pattern
+            if (!matchingTargets.length) {
+                matchingTargets = [targetName];
+            }
+            for (const matchingTargetName of matchingTargets) {
+                updatedProjectConfiguration.targets[matchingTargetName] =
+                    (0, target_merging_1.mergeTargetConfigurations)(normalizedTarget, matchingProject.targets?.[matchingTargetName], sourceMap, sourceInformation, `targets.${matchingTargetName}`);
+            }
+        }
+    }
+    projectRootMap[updatedProjectConfiguration.root] =
+        updatedProjectConfiguration;
+    const nameChanged = !!updatedProjectConfiguration.name &&
+        updatedProjectConfiguration.name !== matchingProject?.name;
+    return { nameChanged };
+}
+function readProjectConfigurationsFromRootMap(projectRootMap) {
+    const projects = {};
+    // If there are projects that have the same name, that is an error.
+    // This object tracks name -> (all roots of projects with that name)
+    // to provide better error messaging.
+    const conflicts = new Map();
+    const projectRootsWithNoName = [];
+    for (const root in projectRootMap) {
+        const project = projectRootMap[root];
+        // We're setting `// targets` as a comment `targets` is empty due to Project Crystal.
+        // Strip it before returning configuration for usage.
+        if (project['// targets'])
+            delete project['// targets'];
+        try {
+            (0, target_normalization_1.validateProject)(project, projects);
+            projects[project.name] = project;
+        }
+        catch (e) {
+            if ((0, error_types_1.isProjectWithNoNameError)(e)) {
+                projectRootsWithNoName.push(e.projectRoot);
+            }
+            else if ((0, error_types_1.isProjectWithExistingNameError)(e)) {
+                const rootErrors = conflicts.get(e.projectName) ?? [
+                    projects[e.projectName].root,
+                ];
+                rootErrors.push(e.projectRoot);
+                conflicts.set(e.projectName, rootErrors);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    if (conflicts.size > 0) {
+        throw new error_types_1.MultipleProjectsWithSameNameError(conflicts, projects);
+    }
+    if (projectRootsWithNoName.length > 0) {
+        throw new error_types_1.ProjectsWithNoNameError(projectRootsWithNoName, projects);
+    }
+    return projects;
+}
+function createRootMap(projectRootMap) {
+    const map = {};
+    for (const projectRoot in projectRootMap) {
+        const projectName = projectRootMap[projectRoot].name;
+        map[projectRoot] = projectName;
+    }
+    return map;
+}
+/**
+ * Owns the rootMap (root → ProjectConfiguration) and nameMap
+ * (name → ProjectConfiguration), coordinating merges with the
+ * {@link ProjectNameInNodePropsManager} for deferred name substitutions.
+ *
+ * The nameMap entries are the *same object references* as the rootMap
+ * entries, so when a merge adds targets to a rootMap entry the nameMap
+ * entry automatically has them too — no copying, no staleness.
+ */
+class ProjectNodesManager {
+    constructor() {
+        // root → ProjectConfiguration (the merge target)
+        this.rootMap = {};
+        // name → ProjectConfiguration (same object references as rootMap)
+        this.nameMap = {};
+        // Pass a lazy accessor so the substitution manager always sees
+        // the current nameMap without manual synchronization.
+        this.nameSubstitutionManager = new name_substitution_manager_1.ProjectNameInNodePropsManager(() => this.nameMap);
+    }
+    getRootMap() {
+        return this.rootMap;
+    }
+    /**
+     * Merges a project into the rootMap, updates the nameMap, and notifies
+     * the substitution manager if the name changed at this root.
+     */
+    mergeProjectNode(project, configurationSourceMaps, sourceInformation) {
+        const previousName = this.rootMap[project.root]?.name;
+        mergeProjectConfigurationIntoRootMap(this.rootMap, project, configurationSourceMaps, sourceInformation);
+        const merged = this.rootMap[project.root];
+        const currentName = merged?.name;
+        if (currentName) {
+            // Remove old nameMap entry on rename
+            if (previousName && previousName !== currentName) {
+                delete this.nameMap[previousName];
+            }
+            // Point nameMap at the same object as rootMap
+            this.nameMap[currentName] = merged;
+            // Notify substitution manager of name change
+            if (currentName !== previousName) {
+                this.nameSubstitutionManager.identifyProjectWithRoot(project.root, currentName);
+            }
+        }
+    }
+    /**
+     * Registers substitutors for a plugin result's project references
+     * in `inputs` and `dependsOn`.
+     */
+    registerSubstitutors(pluginResultProjects) {
+        this.nameSubstitutionManager.registerSubstitutorsForNodeResults(pluginResultProjects);
+    }
+    /**
+     * Applies all pending name substitutions. Call once after all plugin
+     * results have been merged.
+     */
+    applySubstitutions() {
+        this.nameSubstitutionManager.applySubstitutions(this.rootMap);
+    }
+}
+exports.ProjectNodesManager = ProjectNodesManager;

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

@@ -0,0 +1,32 @@
+import { ProjectConfiguration, ProjectMetadata, TargetConfiguration, TargetMetadata } from '../../../config/workspace-json-project-json';
+import { TargetDefaults } from '../../../config/nx-json';
+import type { SourceInformation } from './source-maps';
+export declare function deepClone<T>(obj: T): T;
+export declare function resolveCommandSyntacticSugar(target: TargetConfiguration, key: string): TargetConfiguration;
+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;
+/**
+ * Merges two targets.
+ *
+ * Most properties from `target` will overwrite any properties from `baseTarget`.
+ * Options and configurations are treated differently - they are merged together if the executor definition is compatible.
+ *
+ * @param target The target definition with higher priority
+ * @param baseTarget The target definition that should be overwritten. Can be undefined, in which case the target is returned as-is.
+ * @param projectConfigSourceMap The source map to be filled with metadata about where each property came from
+ * @param sourceInformation The metadata about where the new target was defined
+ * @param targetIdentifier The identifier for the target to merge, used for source map
+ * @returns A merged target configuration
+ */
+export declare function mergeTargetConfigurations(target: TargetConfiguration, baseTarget?: TargetConfiguration, projectConfigSourceMap?: Record<string, SourceInformation>, sourceInformation?: SourceInformation, targetIdentifier?: string): TargetConfiguration;
+/**
+ * Checks if targets options are compatible - used when merging configurations
+ * to avoid merging options for @nx/js:tsc into something like @nx/webpack:webpack.
+ *
+ * If the executors are both specified and don't match, the options aren't considered
+ * "compatible" and shouldn't be merged.
+ */
+export declare function isCompatibleTarget(a: TargetConfiguration, b: TargetConfiguration): boolean;
+export declare function mergeTargetDefaultWithTargetDefinition(targetName: string, project: ProjectConfiguration, targetDefault: Partial<TargetConfiguration>, sourceMap: Record<string, SourceInformation>): TargetConfiguration;
+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];
+//# sourceMappingURL=target-merging.d.ts.map