@nx/js 21.0.0-beta.1 → 21.0.0-beta.2

package/src/plugins/typescript/util.d.ts

@@ -1,5 +1,13 @@
 import { type TargetConfiguration } from '@nx/devkit';
 import { type PackageManagerCommands } from 'nx/src/utils/package-manager';
+import { type ParsedCommandLine } from 'typescript';
+export type ExtendedConfigFile = {
+    filePath: string;
+    externalPackage?: string;
+};
+export type ParsedTsconfigData = Pick<ParsedCommandLine, 'options' | 'projectReferences' | 'raw'> & {
+    extendedConfigFiles: ExtendedConfigFile[];
+};
 /**
  * Allow uses that use incremental builds to run `nx watch-deps` to continuously build all dependencies.
  */
@@ -7,3 +15,4 @@ export declare function addBuildAndWatchDepsTargets(workspaceRoot: string, proje
     buildDepsTargetName?: string;
     watchDepsTargetName?: string;
 }, pmc: PackageManagerCommands): void;
+export declare function isValidPackageJsonBuildConfig(tsConfig: ParsedTsconfigData, workspaceRoot: string, projectRoot: string): boolean;

package/src/plugins/typescript/util.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addBuildAndWatchDepsTargets = addBuildAndWatchDepsTargets;
+exports.isValidPackageJsonBuildConfig = isValidPackageJsonBuildConfig;
 const devkit_1 = require("@nx/devkit");
 const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const path_1 = require("path");
 /**
  * Allow uses that use incremental builds to run `nx watch-deps` to continuously build all dependencies.
@@ -27,8 +29,80 @@ function addBuildAndWatchDepsTargets(workspaceRoot, projectRoot, targets, option
             dependsOn: ['^build'],
         };
         targets[options.watchDepsTargetName ?? 'watch-deps'] = {
+            continuous: true,
             dependsOn: [buildDepsTargetName],
             command: `${pmc.exec} nx watch --projects ${projectName} --includeDependentProjects -- ${pmc.exec} nx ${buildDepsTargetName} ${projectName}`,
         };
     }
 }
+function isValidPackageJsonBuildConfig(tsConfig, workspaceRoot, projectRoot) {
+    const resolvedProjectPath = (0, node_path_1.isAbsolute)(projectRoot)
+        ? (0, node_path_1.relative)(workspaceRoot, projectRoot)
+        : projectRoot;
+    const packageJsonPath = (0, path_1.join)(workspaceRoot, resolvedProjectPath, 'package.json');
+    if (!(0, node_fs_1.existsSync)(packageJsonPath)) {
+        // If the package.json file does not exist.
+        // Assume it's valid because it would be using `project.json` instead.
+        return true;
+    }
+    const packageJson = (0, devkit_1.readJsonFile)(packageJsonPath);
+    const outDir = tsConfig.options.outFile
+        ? (0, node_path_1.dirname)(tsConfig.options.outFile)
+        : tsConfig.options.outDir;
+    const resolvedOutDir = outDir
+        ? (0, node_path_1.resolve)(workspaceRoot, resolvedProjectPath, outDir)
+        : undefined;
+    const isPathSourceFile = (path) => {
+        if (resolvedOutDir) {
+            const pathToCheck = (0, node_path_1.resolve)(workspaceRoot, resolvedProjectPath, path);
+            return !pathToCheck.startsWith(resolvedOutDir);
+        }
+        const ext = (0, node_path_1.extname)(path);
+        // Check that the file extension is a TS file extension. As the source files are in the same directory as the output files.
+        return ['.ts', '.tsx', '.cts', '.mts'].includes(ext);
+    };
+    // Checks if the value is a path within the `src` directory.
+    const containsInvalidPath = (value) => {
+        if (typeof value === 'string') {
+            return isPathSourceFile(value);
+        }
+        else if (typeof value === 'object') {
+            return Object.entries(value).some(([currentKey, subValue]) => {
+                // Skip types and development conditions
+                if (currentKey === 'types' || currentKey === 'development') {
+                    return false;
+                }
+                if (typeof subValue === 'string') {
+                    return isPathSourceFile(subValue);
+                }
+                return false;
+            });
+        }
+        return false;
+    };
+    const exports = packageJson?.exports;
+    // Check the `.` export if `exports` is defined.
+    if (exports) {
+        if (typeof exports === 'string') {
+            return !isPathSourceFile(exports);
+        }
+        if (typeof exports === 'object' && '.' in exports) {
+            return !containsInvalidPath(exports['.']);
+        }
+        // Check other exports if `.` is not defined or valid.
+        for (const key in exports) {
+            if (key !== '.' && containsInvalidPath(exports[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // If `exports` is not defined, fallback to `main` and `module` fields.
+    const buildPaths = ['main', 'module'];
+    for (const field of buildPaths) {
+        if (packageJson[field] && isPathSourceFile(packageJson[field])) {
+            return false;
+        }
+    }
+    return true;
+}

package/src/release/utils/update-lock-file.d.ts

@@ -0,0 +1,10 @@
+export declare function updateLockFile(cwd: string, { dryRun, verbose, useLegacyVersioning, options, }: {
+    dryRun?: boolean;
+    verbose?: boolean;
+    useLegacyVersioning?: boolean;
+    options?: {
+        skipLockFileUpdate?: boolean;
+        installArgs?: string;
+        installIgnoreScripts?: boolean;
+    };
+}): Promise<string[]>;

package/src/{generators/release-version → release}/utils/update-lock-file.js

@@ -7,8 +7,8 @@ const client_1 = require("nx/src/daemon/client/client");
 // eslint-disable-next-line @typescript-eslint/no-restricted-imports
 const lock_file_1 = require("nx/src/plugins/js/lock-file/lock-file");
 const semver_1 = require("semver");
-async function updateLockFile(cwd, { dryRun, verbose, generatorOptions, }) {
-    if (generatorOptions?.skipLockFileUpdate) {
+async function updateLockFile(cwd, { dryRun, verbose, useLegacyVersioning, options, }) {
+    if (options?.skipLockFileUpdate) {
         if (verbose) {
             console.log('\nSkipped lock file update because skipLockFileUpdate was set.');
         }
@@ -36,10 +36,10 @@ async function updateLockFile(cwd, { dryRun, verbose, generatorOptions, }) {
         await client_1.daemonClient.stop();
     }
     const packageManagerCommands = (0, devkit_1.getPackageManagerCommand)(packageManager);
-    let installArgs = generatorOptions?.installArgs || '';
+    let installArgs = options?.installArgs || '';
     devkit_1.output.logSingleLine(`Updating ${packageManager} lock file`);
     let env = {};
-    if (generatorOptions?.installIgnoreScripts) {
+    if (options?.installIgnoreScripts) {
         if (packageManager === 'yarn') {
             env = { YARN_ENABLE_SCRIPTS: 'false' };
         }
@@ -62,7 +62,7 @@ async function updateLockFile(cwd, { dryRun, verbose, generatorOptions, }) {
     if (dryRun) {
         return [];
     }
-    execLockFileUpdate(command, cwd, env);
+    execLockFileUpdate(command, cwd, env, useLegacyVersioning);
     if (isDaemonEnabled) {
         try {
             await client_1.daemonClient.startInBackground();
@@ -79,7 +79,7 @@ async function updateLockFile(cwd, { dryRun, verbose, generatorOptions, }) {
     }
     return [lockFile];
 }
-function execLockFileUpdate(command, cwd, env = {}) {
+function execLockFileUpdate(command, cwd, env, useLegacyVersioning) {
     try {
         const LARGE_BUFFER = 1024 * 1000000;
         (0, child_process_1.execSync)(command, {
@@ -93,13 +93,16 @@ function execLockFileUpdate(command, cwd, env = {}) {
         });
     }
     catch (e) {
+        const configPathStart = useLegacyVersioning
+            ? 'release.version.generatorOptions'
+            : 'release.version.versionActionsOptions';
         devkit_1.output.error({
             title: `Error updating lock file with command '${command}'`,
             bodyLines: [
                 `Verify that '${command}' succeeds when run from the workspace root.`,
-                `To configure a string of arguments to be passed to this command, set the 'release.version.generatorOptions.installArgs' property in nx.json.`,
-                `To ignore install lifecycle scripts, set 'release.version.generatorOptions.installIgnoreScripts' to true in nx.json.`,
-                `To disable this step entirely, set 'release.version.generatorOptions.skipLockFileUpdate' to true in nx.json.`,
+                `To configure a string of arguments to be passed to this command, set the '${configPathStart}.installArgs' property in nx.json.`,
+                `To ignore install lifecycle scripts, set '${configPathStart}.installIgnoreScripts' to true in nx.json.`,
+                `To disable this step entirely, set '${configPathStart}.skipLockFileUpdate' to true in nx.json.`,
             ],
         });
         throw e;

package/src/release/version-actions.d.ts

@@ -0,0 +1,22 @@
+import { ProjectGraph, Tree } from '@nx/devkit';
+import { AfterAllProjectsVersioned, VersionActions } from 'nx/release';
+import type { NxReleaseVersionV2Configuration } from 'nx/src/config/nx-json';
+export declare const afterAllProjectsVersioned: AfterAllProjectsVersioned;
+export default class JsVersionActions extends VersionActions {
+    validManifestFilenames: string[];
+    readCurrentVersionFromSourceManifest(tree: Tree): Promise<{
+        currentVersion: string;
+        manifestPath: string;
+    }>;
+    readCurrentVersionFromRegistry(tree: Tree, currentVersionResolverMetadata: NxReleaseVersionV2Configuration['currentVersionResolverMetadata']): Promise<{
+        currentVersion: string;
+        logText: string;
+    }>;
+    readCurrentVersionOfDependency(tree: Tree, projectGraph: ProjectGraph, dependencyProjectName: string): Promise<{
+        currentVersion: string | null;
+        dependencyCollection: string | null;
+    }>;
+    isLocalDependencyProtocol(versionSpecifier: string): Promise<boolean>;
+    updateProjectVersion(tree: Tree, newVersion: string): Promise<string[]>;
+    updateProjectDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>): Promise<string[]>;
+}

package/src/release/version-actions.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.afterAllProjectsVersioned = void 0;
+const devkit_1 = require("@nx/devkit");
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+const release_1 = require("nx/release");
+const npm_config_1 = require("../utils/npm-config");
+const update_lock_file_1 = require("./utils/update-lock-file");
+const chalk = require("chalk");
+const afterAllProjectsVersioned = async (cwd, opts) => {
+    return {
+        changedFiles: await (0, update_lock_file_1.updateLockFile)(cwd, {
+            ...opts,
+            useLegacyVersioning: false,
+        }),
+        deletedFiles: [],
+    };
+};
+exports.afterAllProjectsVersioned = afterAllProjectsVersioned;
+// Cache at the module level to avoid re-detecting the package manager for each instance
+let pm;
+class JsVersionActions extends release_1.VersionActions {
+    constructor() {
+        super(...arguments);
+        this.validManifestFilenames = ['package.json'];
+    }
+    async readCurrentVersionFromSourceManifest(tree) {
+        const sourcePackageJsonPath = (0, node_path_1.join)(this.projectGraphNode.data.root, 'package.json');
+        try {
+            const packageJson = (0, devkit_1.readJson)(tree, sourcePackageJsonPath);
+            return {
+                manifestPath: sourcePackageJsonPath,
+                currentVersion: packageJson.version,
+            };
+        }
+        catch {
+            throw new Error(`Unable to determine the current version for project "${this.projectGraphNode.name}" from ${sourcePackageJsonPath}, please ensure that the "version" field is set within the package.json file`);
+        }
+    }
+    async readCurrentVersionFromRegistry(tree, currentVersionResolverMetadata) {
+        const sourcePackageJsonPath = (0, node_path_1.join)(this.projectGraphNode.data.root, 'package.json');
+        const packageJson = (0, devkit_1.readJson)(tree, sourcePackageJsonPath);
+        const packageName = packageJson.name;
+        const metadata = currentVersionResolverMetadata;
+        const registryArg = typeof metadata?.registry === 'string' ? metadata.registry : undefined;
+        const tagArg = typeof metadata?.tag === 'string' ? metadata.tag : undefined;
+        const warnFn = (message) => {
+            console.log(chalk.keyword('orange')(message));
+        };
+        const { registry, tag, registryConfigKey } = await (0, npm_config_1.parseRegistryOptions)(devkit_1.workspaceRoot, {
+            packageRoot: this.projectGraphNode.data.root,
+            packageJson,
+        }, {
+            registry: registryArg,
+            tag: tagArg,
+        }, warnFn);
+        let currentVersion = null;
+        try {
+            // Must be non-blocking async to allow spinner to render
+            currentVersion = await new Promise((resolve, reject) => {
+                (0, node_child_process_1.exec)(`npm view ${packageName} version --"${registryConfigKey}=${registry}" --tag=${tag}`, {
+                    windowsHide: false,
+                }, (error, stdout, stderr) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    if (stderr) {
+                        return reject(stderr);
+                    }
+                    return resolve(stdout.trim());
+                });
+            });
+        }
+        catch { }
+        return {
+            currentVersion,
+            // Make troubleshooting easier by including the registry and tag data in the log text
+            logText: `"${registryConfigKey}=${registry}" tag=${tag}`,
+        };
+    }
+    async readCurrentVersionOfDependency(tree, projectGraph, dependencyProjectName) {
+        const sourcePackageJsonPath = (0, node_path_1.join)(this.projectGraphNode.data.root, 'package.json');
+        const json = (0, devkit_1.readJson)(tree, sourcePackageJsonPath);
+        // Resolve the package name from the project graph metadata, as it may not match the project name
+        const dependencyPackageName = projectGraph.nodes[dependencyProjectName].data.metadata?.js?.packageName;
+        const dependencyTypes = [
+            'dependencies',
+            'devDependencies',
+            'peerDependencies',
+            'optionalDependencies',
+        ];
+        let currentVersion = null;
+        let dependencyCollection = null;
+        for (const depType of dependencyTypes) {
+            if (json[depType] && json[depType][dependencyPackageName]) {
+                currentVersion = json[depType][dependencyPackageName];
+                dependencyCollection = depType;
+                break;
+            }
+        }
+        return {
+            currentVersion,
+            dependencyCollection,
+        };
+    }
+    // NOTE: The TODOs were carried over from the original implementation, they are not yet implemented
+    async isLocalDependencyProtocol(versionSpecifier) {
+        const localPackageProtocols = [
+            'file:', // all package managers
+            'workspace:', // not npm
+            // TODO: Support portal protocol at the project graph level before enabling here
+            // 'portal:', // modern yarn only
+        ];
+        // Not using a supported local protocol
+        if (!localPackageProtocols.some((protocol) => versionSpecifier.startsWith(protocol))) {
+            return false;
+        }
+        // Supported by all package managers
+        if (versionSpecifier.startsWith('file:')) {
+            return true;
+        }
+        // Determine specific package manager in use
+        if (!pm) {
+            pm = (0, devkit_1.detectPackageManager)();
+            // pmVersion = getPackageManagerVersion(pm);
+        }
+        if (pm === 'npm' && versionSpecifier.startsWith('workspace:')) {
+            throw new Error(`The "workspace:" protocol is not yet supported by npm (https://github.com/npm/rfcs/issues/765). Please ensure you have a valid setup according to your package manager before attempting to release packages.`);
+        }
+        // TODO: Support portal protocol at the project graph level before enabling here
+        // if (
+        //   version.startsWith('portal:') &&
+        //   (pm !== 'yarn' || lt(pmVersion, '2.0.0'))
+        // ) {
+        //   throw new Error(
+        //     `The "portal:" protocol is only supported by yarn@2.0.0 and above. Please ensure you have a valid setup according to your package manager before attempting to release packages.`
+        //   );
+        // }
+        return true;
+    }
+    async updateProjectVersion(tree, newVersion) {
+        const logMessages = [];
+        for (const manifestPath of this.manifestsToUpdate) {
+            (0, devkit_1.updateJson)(tree, manifestPath, (json) => {
+                json.version = newVersion;
+                return json;
+            });
+            logMessages.push(`✍️  New version ${newVersion} written to manifest: ${manifestPath}`);
+        }
+        return logMessages;
+    }
+    async updateProjectDependencies(tree, projectGraph, dependenciesToUpdate) {
+        const numDependenciesToUpdate = Object.keys(dependenciesToUpdate).length;
+        const depText = numDependenciesToUpdate === 1 ? 'dependency' : 'dependencies';
+        if (numDependenciesToUpdate === 0) {
+            return [];
+        }
+        const logMessages = [];
+        for (const manifestPath of this.manifestsToUpdate) {
+            (0, devkit_1.updateJson)(tree, manifestPath, (json) => {
+                const dependencyTypes = [
+                    'dependencies',
+                    'devDependencies',
+                    'peerDependencies',
+                    'optionalDependencies',
+                ];
+                for (const depType of dependencyTypes) {
+                    if (json[depType]) {
+                        for (const [dep, version] of Object.entries(dependenciesToUpdate)) {
+                            // Resolve the package name from the project graph metadata, as it may not match the project name
+                            const packageName = projectGraph.nodes[dep].data.metadata?.js?.packageName;
+                            if (!packageName) {
+                                throw new Error(`Unable to determine the package name for project "${dep}" from the project graph metadata, please ensure that the "@nx/js" plugin is installed and the project graph has been built. If the issue persists, please report this issue on https://github.com/nrwl/nx/issues`);
+                            }
+                            if (json[depType][packageName]) {
+                                json[depType][packageName] = version;
+                            }
+                        }
+                    }
+                }
+                return json;
+            });
+            logMessages.push(`✍️  Updated ${numDependenciesToUpdate} ${depText} in manifest: ${manifestPath}`);
+        }
+        return logMessages;
+    }
+}
+exports.default = JsVersionActions;

package/src/utils/assets/copy-assets-handler.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CopyAssetsHandler = exports.defaultFileEventHandler = void 0;
-const minimatch_1 = require("minimatch");
+const picomatch = require("picomatch");
 const node_fs_1 = require("node:fs");
 const pathPosix = require("node:path/posix");
 const path = require("node:path");
@@ -9,6 +9,7 @@ const ignore_1 = require("ignore");
 const tinyglobby_1 = require("tinyglobby");
 const devkit_1 = require("@nx/devkit");
 const client_1 = require("nx/src/daemon/client/client");
+const picocolors_1 = require("picocolors");
 const defaultFileEventHandler = (events) => {
     const dirs = new Set(events.map((event) => path.dirname(event.dest)));
     dirs.forEach((d) => (0, node_fs_1.mkdirSync)(d, { recursive: true }));
@@ -24,6 +25,9 @@ const defaultFileEventHandler = (events) => {
         else {
             devkit_1.logger.error(`Unknown file event: ${event.type}`);
         }
+        const eventDir = path.dirname(event.src);
+        const relativeDest = path.relative(eventDir, event.dest);
+        devkit_1.logger.log(`\n${(0, picocolors_1.dim)(relativeDest)}`);
     });
 };
 exports.defaultFileEventHandler = defaultFileEventHandler;
@@ -115,10 +119,12 @@ class CopyAssetsHandler {
     async processWatchEvents(events) {
         const fileEvents = [];
         for (const event of events) {
-            const pathFromRoot = path.relative(this.rootDir, event.path);
+            const pathFromRoot = event.path.startsWith(this.rootDir)
+                ? path.relative(this.rootDir, event.path)
+                : event.path;
             for (const ag of this.assetGlobs) {
-                if ((0, minimatch_1.minimatch)(pathFromRoot, ag.pattern) &&
-                    !ag.ignore?.some((ig) => (0, minimatch_1.minimatch)(pathFromRoot, ig)) &&
+                if (picomatch(ag.pattern)(pathFromRoot) &&
+                    !ag.ignore?.some((ig) => picomatch(ig)(pathFromRoot)) &&
                     !this.ignore.ignores(pathFromRoot)) {
                     const relPath = path.relative(ag.input, pathFromRoot);
                     const destPath = relPath.startsWith('..') ? pathFromRoot : relPath;
@@ -137,7 +143,7 @@ class CopyAssetsHandler {
     }
     filesToEvent(files, assetGlob) {
         return files.reduce((acc, src) => {
-            if (!assetGlob.ignore?.some((ig) => (0, minimatch_1.minimatch)(src, ig)) &&
+            if (!assetGlob.ignore?.some((ig) => picomatch(ig)(src)) &&
                 !this.ignore.ignores(src)) {
                 const relPath = path.relative(assetGlob.input, src);
                 const dest = relPath.startsWith('..') ? src : relPath;

package/src/utils/buildable-libs-utils.d.ts

@@ -33,8 +33,6 @@ export declare function calculateDependenciesFromTaskGraph(taskGraph: TaskGraph,
  */
 export declare function computeCompilerOptionsPaths(tsConfig: string | ts.ParsedCommandLine, dependencies: DependentBuildableProjectNode[]): ts.MapLike<string[]>;
 export declare function createTmpTsConfig(tsconfigPath: string, workspaceRoot: string, projectRoot: string, dependencies: DependentBuildableProjectNode[], useWorkspaceAsBaseUrl?: boolean): string;
-export declare function checkDependentProjectsHaveBeenBuilt(root: string, projectName: string, targetName: string, projectDependencies: DependentBuildableProjectNode[]): boolean;
-export declare function findMissingBuildDependencies(root: string, projectName: string, targetName: string, projectDependencies: DependentBuildableProjectNode[]): DependentBuildableProjectNode[];
 export declare function updatePaths(dependencies: DependentBuildableProjectNode[], paths: Record<string, string[]>): void;
 /**
  * Updates the peerDependencies section in the `dist/lib/xyz/package.json` with

package/src/utils/buildable-libs-utils.js

@@ -5,8 +5,6 @@ exports.calculateProjectDependencies = calculateProjectDependencies;
 exports.calculateDependenciesFromTaskGraph = calculateDependenciesFromTaskGraph;
 exports.computeCompilerOptionsPaths = computeCompilerOptionsPaths;
 exports.createTmpTsConfig = createTmpTsConfig;
-exports.checkDependentProjectsHaveBeenBuilt = checkDependentProjectsHaveBeenBuilt;
-exports.findMissingBuildDependencies = findMissingBuildDependencies;
 exports.updatePaths = updatePaths;
 exports.updateBuildableProjectPackageJsonDependencies = updateBuildableProjectPackageJsonDependencies;
 const devkit_1 = require("@nx/devkit");
@@ -16,6 +14,8 @@ const fileutils_1 = require("nx/src/utils/fileutils");
 const output_1 = require("nx/src/utils/output");
 const path_1 = require("path");
 const ts_config_1 = require("./typescript/ts-config");
+const crypto_1 = require("crypto");
+const project_graph_1 = require("nx/src/config/project-graph");
 function isBuildable(target, node) {
     return (node.data.targets &&
         node.data.targets[target] &&
@@ -48,7 +48,7 @@ function calculateProjectDependencies(projGraph, root, projectName, targetName,
         .map(({ name: dep, isTopLevel }) => {
         let project = null;
         const depNode = projGraph.nodes[dep] || projGraph.externalNodes[dep];
-        if (depNode.type === 'lib') {
+        if ((0, project_graph_1.isProjectGraphProjectNode)(depNode) && depNode.type === 'lib') {
             if (isBuildable(targetName, depNode)) {
                 const libPackageJsonPath = (0, path_1.join)(root, depNode.data.root, 'package.json');
                 project = {
@@ -67,7 +67,7 @@ function calculateProjectDependencies(projGraph, root, projectName, targetName,
                 nonBuildableDependencies.push(dep);
             }
         }
-        else if (depNode.type === 'npm') {
+        else if ((0, project_graph_1.isProjectGraphExternalNode)(depNode)) {
             project = {
                 name: depNode.data.packageName,
                 outputs: [],
@@ -114,7 +114,7 @@ function readTsConfigWithRemappedPaths(originalTsconfigPath, generatedTsconfigPa
     const normalizedTsConfig = (0, path_1.resolve)(workspaceRoot, originalTsconfigPath);
     const normalizedGeneratedTsConfigDir = (0, path_1.resolve)(workspaceRoot, (0, path_1.dirname)(generatedTsconfigPath));
     generatedTsConfig.extends = (0, path_1.relative)(normalizedGeneratedTsConfigDir, normalizedTsConfig);
-    generatedTsConfig.compilerOptions.paths = computeCompilerOptionsPaths(originalTsconfigPath, dependencies);
+    generatedTsConfig.compilerOptions.paths = computeCompilerOptionsPaths(normalizedTsConfig, dependencies);
     if (process.env.NX_VERBOSE_LOGGING_PATH_MAPPINGS === 'true') {
         output_1.output.log({
             title: 'TypeScript path mappings have been rewritten.',
@@ -229,7 +229,7 @@ function computeCompilerOptionsPaths(tsConfig, dependencies) {
     return paths;
 }
 function createTmpTsConfig(tsconfigPath, workspaceRoot, projectRoot, dependencies, useWorkspaceAsBaseUrl = false) {
-    const tmpTsConfigPath = (0, path_1.join)(workspaceRoot, 'tmp', projectRoot, process.env.NX_TASK_TARGET_TARGET ?? 'build', 'tsconfig.generated.json');
+    const tmpTsConfigPath = (0, path_1.join)(workspaceRoot, 'tmp', projectRoot, process.env.NX_TASK_TARGET_TARGET ?? 'build', `tsconfig.generated.${(0, crypto_1.randomUUID)()}.json`);
     if (tsconfigPath === tmpTsConfigPath) {
         return tsconfigPath;
     }
@@ -250,47 +250,16 @@ function cleanupTmpTsConfigFile(tmpTsConfigPath) {
     }
     catch (e) { }
 }
-function checkDependentProjectsHaveBeenBuilt(root, projectName, targetName, projectDependencies) {
-    const missing = findMissingBuildDependencies(root, projectName, targetName, projectDependencies);
-    if (missing.length > 0) {
-        console.error((0, devkit_1.stripIndents) `
-      It looks like all of ${projectName}'s dependencies have not been built yet:
-      ${missing.map((x) => ` - ${x.node.name}`).join('\n')}
-
-      You might be missing a "targetDefaults" configuration in your root nx.json (https://nx.dev/reference/project-configuration#target-defaults),
-      or "dependsOn" configured in ${projectName}'s project.json (https://nx.dev/reference/project-configuration#dependson) 
-    `);
-        return false;
-    }
-    else {
-        return true;
-    }
-}
-function findMissingBuildDependencies(root, projectName, targetName, projectDependencies) {
-    const depLibsToBuildFirst = [];
-    // verify whether all dependent libraries have been built
-    projectDependencies.forEach((dep) => {
-        if (dep.node.type !== 'lib') {
-            return;
-        }
-        const paths = dep.outputs.map((p) => (0, path_1.join)(root, p));
-        if (!paths.some(fileutils_1.directoryExists)) {
-            depLibsToBuildFirst.push(dep);
-        }
-    });
-    return depLibsToBuildFirst;
-}
 function updatePaths(dependencies, paths) {
     const pathsKeys = Object.keys(paths);
     // For each registered dependency
-    dependencies.forEach((dep) => {
-        if (dep.node.type === 'npm') {
-            return;
-        }
+    dependencies
+        .filter((dep) => (0, project_graph_1.isProjectGraphProjectNode)(dep.node))
+        .forEach((dep) => {
         // If there are outputs
         if (dep.outputs && dep.outputs.length > 0) {
             // Directly map the dependency name to the output paths (dist/packages/..., etc.)
-            paths[dep.name] = dep.outputs;
+            paths[dep.name] = dep.outputs.map((output) => output.replace(/(\*|\/[^\/]*\*).*$/, ''));
             // check for secondary entrypoints
             // For each registered path
             for (const path of pathsKeys) {
@@ -350,7 +319,8 @@ function updateBuildableProjectPackageJsonDependencies(root, projectName, target
             !hasDependency(packageJson, 'peerDependencies', packageName)) {
             try {
                 let depVersion;
-                if (entry.node.type === 'lib') {
+                if ((0, project_graph_1.isProjectGraphProjectNode)(entry.node) &&
+                    entry.node.type === 'lib') {
                     const outputs = (0, devkit_1.getOutputsForTargetAndConfiguration)({
                         project: projectName,
                         target: targetName,

package/src/utils/find-npm-dependencies.d.ts

@@ -6,4 +6,5 @@ export declare function findNpmDependencies(workspaceRoot: string, sourceProject
     includeTransitiveDependencies?: boolean;
     ignoredFiles?: string[];
     useLocalPathsForWorkspaceDependencies?: boolean;
+    runtimeHelpers?: string[];
 }): Record<string, string>;

package/src/utils/find-npm-dependencies.js

@@ -22,7 +22,7 @@ function findNpmDependencies(workspaceRoot, sourceProject, projectGraph, project
             return;
         seen?.add(currentProject.name);
         collectDependenciesFromFileMap(workspaceRoot, currentProject, projectGraph, projectFileMap, buildTarget, options.ignoredFiles, options.useLocalPathsForWorkspaceDependencies, collectedDeps);
-        collectHelperDependencies(workspaceRoot, currentProject, projectGraph, buildTarget, collectedDeps);
+        collectHelperDependencies(workspaceRoot, currentProject, projectGraph, buildTarget, options.runtimeHelpers, collectedDeps);
         if (options.includeTransitiveDependencies) {
             const projectDeps = projectGraph.dependencies[currentProject.name];
             for (const dep of projectDeps) {
@@ -114,7 +114,17 @@ function readPackageJson(project, workspaceRoot) {
         return (0, devkit_1.readJsonFile)(packageJsonPath);
     return null;
 }
-function collectHelperDependencies(workspaceRoot, sourceProject, projectGraph, buildTarget, npmDeps) {
+function collectHelperDependencies(workspaceRoot, sourceProject, projectGraph, buildTarget, runtimeHelpers, npmDeps) {
+    if (runtimeHelpers?.length > 0) {
+        for (const helper of runtimeHelpers) {
+            if (!npmDeps[helper] &&
+                projectGraph.externalNodes[`npm:${helper}`]?.type === 'npm') {
+                npmDeps[helper] =
+                    projectGraph.externalNodes[`npm:${helper}`].data.version;
+            }
+        }
+        return;
+    }
     const target = sourceProject.data.targets[buildTarget];
     if (!target)
         return;

package/src/utils/npm-config.js

@@ -78,10 +78,7 @@ async function execAsync(command, cwd) {
     return new Promise((resolve, reject) => {
         (0, child_process_1.exec)(command, { cwd, windowsHide: false }, (error, stdout, stderr) => {
             if (error) {
-                return reject(error);
-            }
-            if (stderr) {
-                return reject(stderr);
+                return reject((stderr ? `${stderr}\n` : '') + error);
             }
             return resolve(stdout.trim());
         });

package/src/utils/package-json/update-package-json.d.ts

@@ -19,6 +19,7 @@ export interface UpdatePackageJsonOption {
     buildableProjectDepsInPackageJsonType?: 'dependencies' | 'peerDependencies';
     generateLockfile?: boolean;
     packageJsonPath?: string;
+    skipDevelopmentExports?: boolean;
 }
 export declare function updatePackageJson(options: UpdatePackageJsonOption, context: ExecutorContext, target: ProjectGraphProjectNode, dependencies: DependentBuildableProjectNode[], fileMap?: ProjectFileMap): void;
 interface Exports {