nx 19.5.0-canary.20240703-4c76b95 → 19.5.0-canary.20240704-28939dd

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "19.5.0-canary.20240703-4c76b95",
+  "version": "19.5.0-canary.20240704-28939dd",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -70,7 +70,7 @@
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
     "ora": "5.3.0",
-    "@nrwl/tao": "19.5.0-canary.20240703-4c76b95"
+    "@nrwl/tao": "19.5.0-canary.20240704-28939dd"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -85,16 +85,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "19.5.0-canary.20240703-4c76b95",
-    "@nx/nx-darwin-arm64": "19.5.0-canary.20240703-4c76b95",
-    "@nx/nx-linux-x64-gnu": "19.5.0-canary.20240703-4c76b95",
-    "@nx/nx-linux-x64-musl": "19.5.0-canary.20240703-4c76b95",
-    "@nx/nx-win32-x64-msvc": "19.5.0-canary.20240703-4c76b95",
-    "@nx/nx-linux-arm64-gnu": "19.5.0-canary.20240703-4c76b95",
-    "@nx/nx-linux-arm64-musl": "19.5.0-canary.20240703-4c76b95",
-    "@nx/nx-linux-arm-gnueabihf": "19.5.0-canary.20240703-4c76b95",
-    "@nx/nx-win32-arm64-msvc": "19.5.0-canary.20240703-4c76b95",
-    "@nx/nx-freebsd-x64": "19.5.0-canary.20240703-4c76b95"
+    "@nx/nx-darwin-x64": "19.5.0-canary.20240704-28939dd",
+    "@nx/nx-darwin-arm64": "19.5.0-canary.20240704-28939dd",
+    "@nx/nx-linux-x64-gnu": "19.5.0-canary.20240704-28939dd",
+    "@nx/nx-linux-x64-musl": "19.5.0-canary.20240704-28939dd",
+    "@nx/nx-win32-x64-msvc": "19.5.0-canary.20240704-28939dd",
+    "@nx/nx-linux-arm64-gnu": "19.5.0-canary.20240704-28939dd",
+    "@nx/nx-linux-arm64-musl": "19.5.0-canary.20240704-28939dd",
+    "@nx/nx-linux-arm-gnueabihf": "19.5.0-canary.20240704-28939dd",
+    "@nx/nx-win32-arm64-msvc": "19.5.0-canary.20240704-28939dd",
+    "@nx/nx-freebsd-x64": "19.5.0-canary.20240704-28939dd"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/plugins/js/utils/register.js

@@ -79,13 +79,7 @@ function getSwcTranspiler(compilerOptions) {
     return typeof cleanupFn === 'function' ? cleanupFn : () => { };
 }
 exports.getSwcTranspiler = getSwcTranspiler;
-const registered = new Set();
 function getTsNodeTranspiler(compilerOptions) {
-    // Just return if transpiler was already registered before.
-    const registrationKey = JSON.stringify(compilerOptions);
-    if (registered.has(registrationKey)) {
-        return () => { };
-    }
     const { register } = require('ts-node');
     // ts-node doesn't provide a cleanup method
     const service = register({
@@ -94,7 +88,6 @@ function getTsNodeTranspiler(compilerOptions) {
         // we already read and provide the compiler options, so prevent ts-node from reading them again
         skipProject: true,
     });
-    registered.add(registrationKey);
     const { transpiler, swc } = service.options;
     // Don't warn if a faster transpiler is enabled
     if (!transpiler && !swc) {
@@ -147,6 +140,7 @@ function filterRecognizedTsConfigTsNodeOptions(jsonObject) {
     const catchMissingProps = null;
     return { recognized: filteredTsConfigOptions, unrecognized };
 }
+const registered = new Map();
 function getTranspiler(compilerOptions, tsConfigRaw) {
     const preferTsNode = process.env.NX_PREFER_TS_NODE === 'true';
     if (!ts) {
@@ -160,13 +154,35 @@ function getTranspiler(compilerOptions, tsConfigRaw) {
     compilerOptions.target = ts.ScriptTarget.ES2021;
     compilerOptions.inlineSourceMap = true;
     compilerOptions.skipLibCheck = true;
-    if (swcNodeInstalled && !preferTsNode) {
-        return () => getSwcTranspiler(compilerOptions);
+    // Just return if transpiler was already registered before.
+    const registrationKey = JSON.stringify(compilerOptions);
+    const registrationEntry = registered.get(registrationKey);
+    if (registered.has(registrationKey)) {
+        registrationEntry.refCount++;
+        return registrationEntry.cleanup;
     }
-    // We can fall back on ts-node if it's available
-    if (tsNodeInstalled) {
-        const tsNodeOptions = filterRecognizedTsConfigTsNodeOptions(tsConfigRaw).recognized;
-        return () => getTsNodeTranspiler(compilerOptions);
+    const _getTranspiler = swcNodeInstalled && !preferTsNode
+        ? getSwcTranspiler
+        : tsNodeInstalled
+            ? // We can fall back on ts-node if it's available
+                getTsNodeTranspiler
+            : undefined;
+    if (_getTranspiler) {
+        const transpilerCleanup = _getTranspiler(compilerOptions);
+        const currRegistrationEntry = {
+            refCount: 1,
+            cleanup: () => {
+                return () => {
+                    currRegistrationEntry.refCount--;
+                    if (currRegistrationEntry.refCount === 0) {
+                        registered.delete(registrationKey);
+                        transpilerCleanup();
+                    }
+                };
+            },
+        };
+        registered.set(registrationKey, currRegistrationEntry);
+        return currRegistrationEntry.cleanup;
     }
 }
 exports.getTranspiler = getTranspiler;

package/src/project-graph/plugins/internal-api.js

@@ -107,7 +107,6 @@ async function normalizePlugins(plugins, root) {
 async function getDefaultPlugins(root) {
     return [
         (0, path_1.join)(__dirname, '../../plugins/js'),
-        (0, path_1.join)(__dirname, '../../plugins/target-defaults/target-defaults-plugin'),
         ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
             ? [(0, path_1.join)(__dirname, '../../adapter/angular-json')]
             : []),

package/src/project-graph/plugins/isolation/plugin-pool.js

@@ -235,7 +235,7 @@ async function startPluginWorker() {
         workerPath,
         ipcPath,
     ], {
-        stdio: process.stdout.isTTY ? 'inherit' : 'ignore',
+        stdio: 'inherit',
         env,
         detached: true,
         shell: false,

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

@@ -1,15 +1,10 @@
 import { NxJsonConfiguration, TargetDefaults } from '../../config/nx-json';
 import { ProjectGraphExternalNode } from '../../config/project-graph';
 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 | null, plugin: string];
 export type ConfigurationSourceMaps = Record<string, Record<string, SourceInformation>>;
-export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Record<string, ProjectConfiguration>, project: ProjectConfiguration & {
-    targets?: Record<string, TargetConfiguration & {
-        [ONLY_MODIFIES_EXISTING_TARGET]?: boolean;
-    }>;
-}, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation, skipTargetNormalization?: boolean): void;
+export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Record<string, ProjectConfiguration>, project: ProjectConfiguration, 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 = {
     /**
@@ -44,6 +39,7 @@ export declare function createProjectConfigurations(root: string, nxJson: NxJson
 plugins: LoadedNxPlugin[]): Promise<ConfigurationResult>;
 export declare function readProjectConfigurationsFromRootMap(projectRootMap: Record<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
 export declare function validateProject(project: ProjectConfiguration, knownProjects: Record<string, ProjectConfiguration>): void;
+export declare function mergeTargetDefaultWithTargetDefinition(targetName: string, project: ProjectConfiguration, targetDefault: Partial<TargetConfiguration>, sourceMap: Record<string, SourceInformation>): TargetConfiguration;
 /**
  * Merges two targets.
  *
@@ -68,4 +64,10 @@ 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];
+/**
+ * Expand's `command` syntactic sugar and replaces tokens in options.
+ * @param target The target to normalize
+ * @param project The project that the target belongs to
+ * @returns The normalized target configuration
+ */
 export declare function normalizeTarget(target: TargetConfiguration, project: ProjectConfiguration): TargetConfiguration<any>;

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

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeTarget = exports.readTargetDefaultsForTarget = exports.resolveNxTokensInOptions = exports.isCompatibleTarget = exports.mergeTargetConfigurations = exports.validateProject = exports.readProjectConfigurationsFromRootMap = exports.createProjectConfigurations = exports.mergeMetadata = exports.mergeProjectConfigurationIntoRootMap = void 0;
+exports.normalizeTarget = exports.readTargetDefaultsForTarget = exports.resolveNxTokensInOptions = exports.isCompatibleTarget = exports.mergeTargetConfigurations = exports.mergeTargetDefaultWithTargetDefinition = exports.validateProject = 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");
-const symbols_1 = require("../../plugins/target-defaults/symbols");
 const minimatch_1 = require("minimatch");
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
@@ -120,22 +119,13 @@ skipTargetNormalization) {
             // 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 && !target?.[symbols_1.ONLY_MODIFIES_EXISTING_TARGET]) {
+            if (sourceMap) {
                 sourceMap[`targets.${targetName}`] = sourceInformation;
             }
-            // If ONLY_MODIFIES_EXISTING_TARGET is true, and its not on the matching project
-            // we shouldn't merge its info into the graph
-            if (target?.[symbols_1.ONLY_MODIFIES_EXISTING_TARGET] &&
-                !matchingProject.targets?.[targetName]) {
-                continue;
-            }
             const normalizedTarget = skipTargetNormalization
                 ? target
                 : resolveCommandSyntacticSugar(target, project.root);
             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;
         }
     }
@@ -263,7 +253,7 @@ plugins) {
         results.push(r);
     }
     return Promise.all(results).then((results) => {
-        const { projectRootMap, externalNodes, rootMap, configurationSourceMaps } = mergeCreateNodesResults(results, errors);
+        const { projectRootMap, externalNodes, rootMap, configurationSourceMaps } = mergeCreateNodesResults(results, nxJson, errors);
         perf_hooks_1.performance.mark('build-project-configs:end');
         perf_hooks_1.performance.measure('build-project-configs', 'build-project-configs:start', 'build-project-configs:end');
         if (errors.length === 0) {
@@ -287,7 +277,7 @@ plugins) {
     });
 }
 exports.createProjectConfigurations = createProjectConfigurations;
-function mergeCreateNodesResults(results, errors) {
+function mergeCreateNodesResults(results, nxJsonConfiguration, errors) {
     perf_hooks_1.performance.mark('createNodes:merge - start');
     const projectRootMap = {};
     const externalNodes = {};
@@ -296,9 +286,6 @@ function mergeCreateNodesResults(results, errors) {
         const [pluginName, file, nodes] = result;
         const { projects: projectNodes, externalNodes: pluginExternalNodes } = nodes;
         const sourceInfo = [file, pluginName];
-        if (result[symbols_1.OVERRIDE_SOURCE_FILE]) {
-            sourceInfo[0] = result[symbols_1.OVERRIDE_SOURCE_FILE];
-        }
         for (const node in projectNodes) {
             // Handles `{projects: {'libs/foo': undefined}}`.
             if (!projectNodes[node]) {
@@ -322,7 +309,7 @@ function mergeCreateNodesResults(results, errors) {
         Object.assign(externalNodes, pluginExternalNodes);
     }
     try {
-        validateAndNormalizeProjectRootMap(projectRootMap);
+        validateAndNormalizeProjectRootMap(projectRootMap, nxJsonConfiguration, configurationSourceMaps);
     }
     catch (e) {
         if ((0, error_types_1.isProjectsWithNoNameError)(e) ||
@@ -401,7 +388,7 @@ function readProjectConfigurationsFromRootMap(projectRootMap) {
     return projects;
 }
 exports.readProjectConfigurationsFromRootMap = readProjectConfigurationsFromRootMap;
-function validateAndNormalizeProjectRootMap(projectRootMap) {
+function validateAndNormalizeProjectRootMap(projectRootMap, nxJsonConfiguration, sourceMaps = {}) {
     // Name -> Project, used to validate that all projects have unique names
     const projects = {};
     // If there are projects that have the same name, that is an error.
@@ -434,24 +421,7 @@ function validateAndNormalizeProjectRootMap(projectRootMap) {
                 throw e;
             }
         }
-        for (const targetName in project.targets) {
-            project.targets[targetName] = normalizeTarget(project.targets[targetName], project);
-            if (
-            // If the target has no executor or command, it doesn't do anything
-            !project.targets[targetName].executor &&
-                !project.targets[targetName].command) {
-                // But it may have dependencies that do something
-                if (project.targets[targetName].dependsOn &&
-                    project.targets[targetName].dependsOn.length > 0) {
-                    project.targets[targetName].executor = 'nx:noop';
-                }
-                else {
-                    // If it does nothing, and has no depenencies,
-                    // we can remove it.
-                    delete project.targets[targetName];
-                }
-            }
-        }
+        normalizeTargets(project, sourceMaps, nxJsonConfiguration);
     }
     if (conflicts.size > 0) {
         throw new error_types_1.MultipleProjectsWithSameNameError(conflicts, projects);
@@ -461,6 +431,33 @@ function validateAndNormalizeProjectRootMap(projectRootMap) {
     }
     return projectRootMap;
 }
+function normalizeTargets(project, sourceMaps, nxJsonConfiguration) {
+    for (const targetName in project.targets) {
+        project.targets[targetName] = normalizeTarget(project.targets[targetName], project);
+        const projectSourceMaps = sourceMaps[project.root];
+        const targetConfig = project.targets[targetName];
+        const targetDefaults = readTargetDefaultsForTarget(targetName, nxJsonConfiguration.targetDefaults, targetConfig.executor);
+        // We only apply defaults if they exist
+        if (targetDefaults && isCompatibleTarget(targetConfig, targetDefaults)) {
+            project.targets[targetName] = mergeTargetDefaultWithTargetDefinition(targetName, project, normalizeTarget(targetDefaults, project), projectSourceMaps);
+        }
+        if (
+        // If the target has no executor or command, it doesn't do anything
+        !project.targets[targetName].executor &&
+            !project.targets[targetName].command) {
+            // But it may have dependencies that do something
+            if (project.targets[targetName].dependsOn &&
+                project.targets[targetName].dependsOn.length > 0) {
+                project.targets[targetName].executor = 'nx:noop';
+            }
+            else {
+                // If it does nothing, and has no depenencies,
+                // we can remove it.
+                delete project.targets[targetName];
+            }
+        }
+    }
+}
 function validateProject(project, 
 // name -> project
 knownProjects) {
@@ -482,6 +479,75 @@ knownProjects) {
     }
 }
 exports.validateProject = validateProject;
+function targetDefaultShouldBeApplied(key, sourceMap) {
+    const sourceInfo = sourceMap[key];
+    if (!sourceInfo) {
+        return true;
+    }
+    // The defined value of the target is from a plugin that
+    // isn't part of Nx's core plugins, so target defaults are
+    // applied on top of it.
+    const [, plugin] = sourceInfo;
+    return !plugin?.startsWith('nx/');
+}
+function mergeTargetDefaultWithTargetDefinition(targetName, project, targetDefault, sourceMap) {
+    const targetDefinition = project.targets[targetName] ?? {};
+    const result = JSON.parse(JSON.stringify(targetDefinition));
+    for (const key in targetDefault) {
+        switch (key) {
+            case 'options': {
+                const normalizedDefaults = resolveNxTokensInOptions(targetDefault.options, project, targetName);
+                for (const optionKey in normalizedDefaults) {
+                    const sourceMapKey = `targets.${targetName}.options.${optionKey}`;
+                    if (targetDefinition.options[optionKey] === undefined ||
+                        targetDefaultShouldBeApplied(sourceMapKey, sourceMap)) {
+                        result.options[optionKey] = targetDefault.options[optionKey];
+                        sourceMap[sourceMapKey] = ['nx.json', 'nx/target-defaults'];
+                    }
+                }
+                break;
+            }
+            case 'configurations': {
+                if (!result.configurations) {
+                    result.configurations = {};
+                    sourceMap[`targets.${targetName}.configurations`] = [
+                        'nx.json',
+                        'nx/target-defaults',
+                    ];
+                }
+                for (const configuration in targetDefault.configurations) {
+                    if (!result.configurations[configuration]) {
+                        result.configurations[configuration] = {};
+                        sourceMap[`targets.${targetName}.configurations.${configuration}`] =
+                            ['nx.json', 'nx/target-defaults'];
+                    }
+                    const normalizedConfigurationDefaults = resolveNxTokensInOptions(targetDefault.configurations[configuration], project, targetName);
+                    for (const configurationKey in normalizedConfigurationDefaults) {
+                        const sourceMapKey = `targets.${targetName}.configurations.${configuration}.${configurationKey}`;
+                        if (targetDefinition.configurations?.[configuration]?.[configurationKey] === undefined ||
+                            targetDefaultShouldBeApplied(sourceMapKey, sourceMap)) {
+                            result.configurations[configuration][configurationKey] =
+                                targetDefault.configurations[configuration][configurationKey];
+                            sourceMap[sourceMapKey] = ['nx.json', 'nx/target-defaults'];
+                        }
+                    }
+                }
+                break;
+            }
+            default: {
+                const sourceMapKey = `targets.${targetName}.${key}`;
+                if (targetDefinition[key] === undefined ||
+                    targetDefaultShouldBeApplied(sourceMapKey, sourceMap)) {
+                    result[key] = targetDefault[key];
+                    sourceMap[sourceMapKey] = ['nx.json', 'nx/target-defaults'];
+                }
+                break;
+            }
+        }
+    }
+    return result;
+}
+exports.mergeTargetDefaultWithTargetDefinition = mergeTargetDefaultWithTargetDefinition;
 /**
  * Merges two targets.
  *
@@ -500,13 +566,6 @@ function mergeTargetConfigurations(target, baseTarget, projectConfigSourceMap, s
     // 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(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
-    // equaling info that should have only been used to modify the existing target.
-    if (!isCompatible && target[symbols_1.ONLY_MODIFIES_EXISTING_TARGET]) {
-        return baseTarget;
-    }
     if (!isCompatible && projectConfigSourceMap) {
         // if the target is not compatible, we will simply override the options
         // we have to delete old entries from the source map
@@ -680,6 +739,12 @@ function resolveCommandSyntacticSugar(target, key) {
         };
     }
 }
+/**
+ * Expand's `command` syntactic sugar and replaces tokens in options.
+ * @param target The target to normalize
+ * @param project The project that the target belongs to
+ * @returns The normalized target configuration
+ */
 function normalizeTarget(target, project) {
     target = resolveCommandSyntacticSugar(target, project.root);
     target.options = resolveNxTokensInOptions(target.options, project, `${project.root}:${target}`);

package/src/tasks-runner/utils.js

@@ -131,7 +131,7 @@ function getOutputsForTargetAndConfiguration(taskTargetOrTask, overridesOrNode,
     const { target, configuration } = taskTarget;
     const targetConfiguration = node.data.targets[target];
     const options = {
-        ...targetConfiguration.options,
+        ...targetConfiguration?.options,
         ...targetConfiguration?.configurations?.[configuration],
         ...overrides,
     };

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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDefaultPluginsSync = void 0;
 const angular_json_1 = require("../adapter/angular-json");
 const project_json_1 = require("../plugins/project-json/build-nodes/project-json");
-const target_defaults_plugin_1 = require("../plugins/target-defaults/target-defaults-plugin");
 const PackageJsonWorkspacesPlugin = require("../plugins/package-json-workspaces");
 /**
  * @todo(@agentender) v20: Remove this fn when we remove readWorkspaceConfig
@@ -14,7 +13,6 @@ function getDefaultPluginsSync(root) {
         ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
             ? [require('../adapter/angular-json').NxAngularJsonPlugin]
             : []),
-        target_defaults_plugin_1.default,
         PackageJsonWorkspacesPlugin,
         project_json_1.default,
     ];

package/src/plugins/target-defaults/symbols.d.ts

@@ -1,17 +0,0 @@
-/**
- * This marks that a target provides information which should modify a target already registered
- * on the project via other plugins. If the target has not already been registered, and this symbol is true,
- * the information provided by it will be discarded.
- *
- * NOTE: This cannot be a symbol, as they are not serialized in JSON the communication
- * between the plugin-worker and the main process.
- */
-export declare const ONLY_MODIFIES_EXISTING_TARGET = "NX_ONLY_MODIFIES_EXISTING_TARGET";
-/**
- * This is used to override the source file for the target defaults plugin.
- * This allows the plugin to use the project files as the context, but point to nx.json as the source file.
- *
- * NOTE: This cannot be a symbol, as they are not serialized in JSON the communication
- * between the plugin-worker and the main process.
- */
-export declare const OVERRIDE_SOURCE_FILE = "NX_OVERRIDE_SOURCE_FILE";

package/src/plugins/target-defaults/symbols.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OVERRIDE_SOURCE_FILE = exports.ONLY_MODIFIES_EXISTING_TARGET = void 0;
-/**
- * This marks that a target provides information which should modify a target already registered
- * on the project via other plugins. If the target has not already been registered, and this symbol is true,
- * the information provided by it will be discarded.
- *
- * NOTE: This cannot be a symbol, as they are not serialized in JSON the communication
- * between the plugin-worker and the main process.
- */
-exports.ONLY_MODIFIES_EXISTING_TARGET = 'NX_ONLY_MODIFIES_EXISTING_TARGET';
-/**
- * This is used to override the source file for the target defaults plugin.
- * This allows the plugin to use the project files as the context, but point to nx.json as the source file.
- *
- * NOTE: This cannot be a symbol, as they are not serialized in JSON the communication
- * between the plugin-worker and the main process.
- */
-exports.OVERRIDE_SOURCE_FILE = 'NX_OVERRIDE_SOURCE_FILE';

package/src/plugins/target-defaults/target-defaults-plugin.d.ts

@@ -1,121 +0,0 @@
-import { TargetConfiguration } from '../../config/workspace-json-project-json';
-import { NxPluginV2 } from '../../project-graph/plugins';
-export declare const TargetDefaultsPlugin: NxPluginV2;
-export default TargetDefaultsPlugin;
-/**
- * This fn gets target info that would make a target uniquely compatible
- * with what is described by project.json or package.json. As the merge process
- * for config happens, without this, the target defaults may be compatible
- * with a config from a plugin and then that combined target be incompatible
- * with the project json configuration resulting in the target default values
- * being scrapped. By adding enough information from the project.json / package.json,
- * we can make sure that the target after merging is compatible with the defined target.
- */
-export declare function getTargetInfo(target: string, projectJsonTargets: Record<string, TargetConfiguration>, packageJsonTargets: Record<string, TargetConfiguration>): {
-    command: string;
-    metadata: {
-        [x: string]: any;
-        description?: string;
-        technologies?: string[];
-        nonAtomizedTarget?: string;
-        help?: {
-            command: string;
-            example: {
-                options?: Record<string, unknown>;
-                args?: string[];
-            };
-        };
-    };
-    executor?: undefined;
-    options?: undefined;
-} | {
-    executor: string;
-    options: {
-        command: any;
-        commands?: undefined;
-        script?: undefined;
-    };
-    metadata: {
-        [x: string]: any;
-        description?: string;
-        technologies?: string[];
-        nonAtomizedTarget?: string;
-        help?: {
-            command: string;
-            example: {
-                options?: Record<string, unknown>;
-                args?: string[];
-            };
-        };
-    };
-    command?: undefined;
-} | {
-    executor: string;
-    options: {
-        commands: any;
-        command?: undefined;
-        script?: undefined;
-    };
-    metadata: {
-        [x: string]: any;
-        description?: string;
-        technologies?: string[];
-        nonAtomizedTarget?: string;
-        help?: {
-            command: string;
-            example: {
-                options?: Record<string, unknown>;
-                args?: string[];
-            };
-        };
-    };
-    command?: undefined;
-} | {
-    executor: string;
-    metadata: {
-        [x: string]: any;
-        description?: string;
-        technologies?: string[];
-        nonAtomizedTarget?: string;
-        help?: {
-            command: string;
-            example: {
-                options?: Record<string, unknown>;
-                args?: string[];
-            };
-        };
-    };
-    command?: undefined;
-    options?: undefined;
-} | {
-    executor: string;
-    options: {
-        script: any;
-        command?: undefined;
-        commands?: undefined;
-    };
-    metadata: {
-        [x: string]: any;
-        description?: string;
-        technologies?: string[];
-        nonAtomizedTarget?: string;
-        help?: {
-            command: string;
-            example: {
-                options?: Record<string, unknown>;
-                args?: string[];
-            };
-        };
-    };
-    command?: undefined;
-} | {
-    executor: string;
-    command?: undefined;
-    metadata?: undefined;
-    options?: undefined;
-} | {
-    command?: undefined;
-    metadata?: undefined;
-    executor?: undefined;
-    options?: undefined;
-};

package/src/plugins/target-defaults/target-defaults-plugin.js

@@ -1,176 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTargetInfo = exports.TargetDefaultsPlugin = void 0;
-const minimatch_1 = require("minimatch");
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const fileutils_1 = require("../../utils/fileutils");
-const globs_1 = require("../../utils/globs");
-const package_json_1 = require("../../utils/package-json");
-const package_json_workspaces_1 = require("../package-json-workspaces");
-const symbols_1 = require("./symbols");
-exports.TargetDefaultsPlugin = {
-    name: 'nx/core/target-defaults',
-    createNodes: [
-        '{package.json,**/package.json,project.json,**/project.json}',
-        (configFile, _, ctx) => {
-            const fileName = (0, node_path_1.basename)(configFile);
-            const root = (0, node_path_1.dirname)(configFile);
-            const packageManagerWorkspacesGlob = (0, globs_1.combineGlobPatterns)((0, package_json_workspaces_1.getGlobPatternsFromPackageManagerWorkspaces)(ctx.workspaceRoot));
-            // Only process once if package.json + project.json both exist
-            if (fileName === 'package.json' &&
-                (0, node_fs_1.existsSync)((0, node_path_1.join)(ctx.workspaceRoot, root, 'project.json'))) {
-                return {};
-            }
-            else if (fileName === 'package.json' &&
-                !(0, minimatch_1.minimatch)(configFile, packageManagerWorkspacesGlob)) {
-                return {};
-            }
-            // If no target defaults, this does nothing
-            const targetDefaults = ctx.nxJsonConfiguration?.targetDefaults;
-            if (!targetDefaults) {
-                return {};
-            }
-            const projectJson = readJsonOrNull((0, node_path_1.join)(ctx.workspaceRoot, root, 'project.json'));
-            const packageJson = readJsonOrNull((0, node_path_1.join)(ctx.workspaceRoot, root, 'package.json'));
-            const packageJsonTargets = (0, package_json_1.readTargetsFromPackageJson)(packageJson);
-            const projectDefinedTargets = new Set([
-                ...Object.keys(projectJson?.targets ?? {}),
-                ...(packageJson ? Object.keys(packageJsonTargets) : []),
-            ]);
-            const executorToTargetMap = getExecutorToTargetMap(packageJsonTargets, projectJson?.targets);
-            const modifiedTargets = {};
-            for (const defaultSpecifier in targetDefaults) {
-                const targetNames = executorToTargetMap.get(defaultSpecifier) ?? new Set();
-                targetNames.add(defaultSpecifier);
-                for (const targetName of targetNames) {
-                    // Prevents `build` from overwriting `@nx/js:tsc` if both are present
-                    // and build is specified later in the ordering.
-                    if (!modifiedTargets[targetName] || targetName !== defaultSpecifier) {
-                        const defaults = JSON.parse(JSON.stringify(targetDefaults[defaultSpecifier]));
-                        modifiedTargets[targetName] = {
-                            ...getTargetInfo(targetName, projectJson?.targets, packageJsonTargets),
-                            ...defaults,
-                        };
-                    }
-                    // TODO: Remove this after we figure out a way to define new targets
-                    // in target defaults
-                    if (!projectDefinedTargets.has(targetName)) {
-                        modifiedTargets[targetName][symbols_1.ONLY_MODIFIES_EXISTING_TARGET] = true;
-                    }
-                }
-            }
-            return {
-                projects: {
-                    [root]: {
-                        targets: modifiedTargets,
-                    },
-                },
-                [symbols_1.OVERRIDE_SOURCE_FILE]: 'nx.json',
-            };
-        },
-    ],
-};
-exports.default = exports.TargetDefaultsPlugin;
-function getExecutorToTargetMap(packageJsonTargets, projectJsonTargets) {
-    const executorToTargetMap = new Map();
-    const targets = Object.keys({
-        ...projectJsonTargets,
-        ...packageJsonTargets,
-    });
-    for (const target of targets) {
-        const executor = getTargetExecutor(target, projectJsonTargets, packageJsonTargets);
-        const targetsForExecutor = executorToTargetMap.get(executor) ?? new Set();
-        targetsForExecutor.add(target);
-        executorToTargetMap.set(executor, targetsForExecutor);
-    }
-    return executorToTargetMap;
-}
-function readJsonOrNull(path) {
-    if ((0, node_fs_1.existsSync)(path)) {
-        return (0, fileutils_1.readJsonFile)(path);
-    }
-    else {
-        return null;
-    }
-}
-/**
- * This fn gets target info that would make a target uniquely compatible
- * with what is described by project.json or package.json. As the merge process
- * for config happens, without this, the target defaults may be compatible
- * with a config from a plugin and then that combined target be incompatible
- * with the project json configuration resulting in the target default values
- * being scrapped. By adding enough information from the project.json / package.json,
- * we can make sure that the target after merging is compatible with the defined target.
- */
-function getTargetInfo(target, projectJsonTargets, packageJsonTargets) {
-    const projectJsonTarget = projectJsonTargets?.[target];
-    const packageJsonTarget = packageJsonTargets?.[target];
-    const executor = getTargetExecutor(target, projectJsonTargets, packageJsonTargets);
-    const targetOptions = {
-        ...packageJsonTarget?.options,
-        ...projectJsonTarget?.options,
-    };
-    const metadata = {
-        ...packageJsonTarget?.metadata,
-        ...projectJsonTarget?.metadata,
-    };
-    if (projectJsonTarget?.command) {
-        return {
-            command: projectJsonTarget?.command,
-            metadata,
-        };
-    }
-    if (executor === 'nx:run-commands') {
-        if (targetOptions?.command) {
-            return {
-                executor: 'nx:run-commands',
-                options: {
-                    command: targetOptions?.command,
-                },
-                metadata,
-            };
-        }
-        else if (targetOptions?.commands) {
-            return {
-                executor: 'nx:run-commands',
-                options: {
-                    commands: targetOptions.commands,
-                },
-                metadata,
-            };
-        }
-        return {
-            executor: 'nx:run-commands',
-            metadata,
-        };
-    }
-    if (executor === 'nx:run-script') {
-        return {
-            executor: 'nx:run-script',
-            options: {
-                script: targetOptions?.script ?? target,
-            },
-            metadata,
-        };
-    }
-    if (executor) {
-        return { executor };
-    }
-    return {};
-}
-exports.getTargetInfo = getTargetInfo;
-function getTargetExecutor(target, projectJsonTargets, packageJsonTargets) {
-    const projectJsonTargetConfiguration = projectJsonTargets?.[target];
-    const packageJsonTargetConfiguration = packageJsonTargets?.[target];
-    if (!projectJsonTargetConfiguration && packageJsonTargetConfiguration) {
-        return packageJsonTargetConfiguration?.executor;
-    }
-    if (projectJsonTargetConfiguration?.executor) {
-        return projectJsonTargetConfiguration.executor;
-    }
-    if (projectJsonTargetConfiguration?.command) {
-        return 'nx:run-commands';
-    }
-    return null;
-}