@nx/js 16.6.0-beta.3 → 16.6.0-beta.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "16.6.0-beta.3",
+  "version": "16.6.0-beta.5",
   "private": false,
   "description": "The JS plugin for Nx contains executors and generators that provide the best experience for developing JavaScript and TypeScript projects. ",
   "repository": {
@@ -32,16 +32,16 @@
   "executors": "./executors.json",
   "builders": "./executors.json",
   "dependencies": {
-    "@babel/core": "^7.15.0",
-    "@babel/plugin-proposal-class-properties": "^7.14.5",
-    "@babel/plugin-proposal-decorators": "^7.14.5",
-    "@babel/plugin-transform-runtime": "^7.15.0",
-    "@babel/preset-env": "^7.15.0",
-    "@babel/preset-typescript": "^7.15.0",
-    "@babel/runtime": "^7.14.8",
-    "@nrwl/js": "16.6.0-beta.3",
-    "@nx/devkit": "16.6.0-beta.3",
-    "@nx/workspace": "16.6.0-beta.3",
+    "@babel/core": "^7.22.9",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-proposal-decorators": "^7.22.7",
+    "@babel/plugin-transform-runtime": "^7.22.9",
+    "@babel/preset-env": "^7.22.9",
+    "@babel/preset-typescript": "^7.22.5",
+    "@babel/runtime": "^7.22.6",
+    "@nrwl/js": "16.6.0-beta.5",
+    "@nx/devkit": "16.6.0-beta.5",
+    "@nx/workspace": "16.6.0-beta.5",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^2.8.0",
@@ -71,5 +71,5 @@
     "access": "public"
   },
   "types": "./src/index.d.ts",
-  "gitHead": "cd8c61d7a3b8ab9bc7bab068f5ca49bbf14abbf5"
+  "gitHead": "aab868aa0c30949832fe2c4b9cb109c204442e39"
 }

package/src/executors/node/node.impl.js

@@ -32,6 +32,11 @@ function nodeExecutor(options, context) {
             throw new Error(`Cannot find build target ${chalk.bold(options.buildTarget)} for project ${chalk.bold(context.projectName)}`);
         }
         const buildTargetExecutor = (_c = project.data.targets[buildTarget.target]) === null || _c === void 0 ? void 0 : _c.executor;
+        if (buildTargetExecutor === 'nx:run-commands' ||
+            buildTargetExecutor === '@nrwl/workspace:run-commands') {
+            // Run commands does not emit build event, so we have to switch to run entire build through Nx CLI.
+            options.runBuildTargetDependencies = true;
+        }
         const buildOptions = Object.assign(Object.assign({}, (0, devkit_1.readTargetOptions)(buildTarget, context)), options.buildTargetOptions);
         if (options.waitUntilTargets && options.waitUntilTargets.length > 0) {
             const results = yield tslib_1.__await(runWaitUntilTargets(options, context));
@@ -44,8 +49,9 @@ function nodeExecutor(options, context) {
         // Re-map buildable workspace projects to their output directory.
         const mappings = calculateResolveMappings(context, options);
         const fileToRun = getFileToRun(context, project, buildOptions, buildTargetExecutor);
-        const tasks = [];
+        let additionalExitHandler = null;
         let currentTask = null;
+        const tasks = [];
         yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues((0, async_iterable_1.createAsyncIterable)(({ done, next, error }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
             var _e;
             const processQueue = () => tslib_1.__awaiter(this, void 0, void 0, function* () {
@@ -58,59 +64,22 @@ function nodeExecutor(options, context) {
                 yield task.start();
             });
             const debouncedProcessQueue = debounce(processQueue, (_e = options.debounce) !== null && _e !== void 0 ? _e : 1000);
-            const addToQueue = () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const addToQueue = (childProcess, buildResult) => tslib_1.__awaiter(this, void 0, void 0, function* () {
                 const task = {
                     id: (0, crypto_1.randomUUID)(),
                     killed: false,
-                    childProcess: null,
+                    childProcess,
                     promise: null,
                     start: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                        if (options.runBuildTargetDependencies) {
-                            // If task dependencies are to be run, then we need to run through CLI since `runExecutor` doesn't support it.
-                            task.promise = new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                                task.childProcess = (0, child_process_1.fork)(require.resolve('nx'), [
-                                    'run',
-                                    `${context.projectName}:${buildTarget.target}${buildTarget.configuration
-                                        ? `:${buildTarget.configuration}`
-                                        : ''}`,
-                                ], {
-                                    cwd: context.root,
-                                    stdio: 'inherit',
-                                });
-                                task.childProcess.once('exit', (code) => {
-                                    if (code === 0)
-                                        resolve();
-                                    else
-                                        reject();
-                                });
-                            }));
-                        }
-                        else {
-                            const output = yield (0, devkit_1.runExecutor)(buildTarget, Object.assign(Object.assign({}, options.buildTargetOptions), { watch: false }), context);
-                            task.promise = new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                                var _g;
-                                let error = false;
-                                let event;
-                                do {
-                                    event = yield output.next();
-                                    if (((_g = event.value) === null || _g === void 0 ? void 0 : _g.success) === false) {
-                                        error = true;
-                                    }
-                                } while (!event.done);
-                                if (error)
-                                    reject();
-                                else
-                                    resolve();
-                            }));
-                        }
                         // Wait for build to finish.
-                        try {
-                            yield task.promise;
-                        }
-                        catch (_f) {
+                        const result = yield buildResult;
+                        if (!result.success) {
                             // If in watch-mode, don't throw or else the process exits.
                             if (options.watch) {
-                                devkit_1.logger.error(`Build failed, waiting for changes to restart...`);
+                                if (!task.killed) {
+                                    // Only log build error if task was not killed by a new change.
+                                    devkit_1.logger.error(`Build failed, waiting for changes to restart...`);
+                                }
                                 return;
                             }
                             else {
@@ -160,55 +129,88 @@ function nodeExecutor(options, context) {
                         try {
                             yield task.promise;
                         }
-                        catch (_h) {
+                        catch (_f) {
                             // Doesn't matter if task fails, we just need to wait until it finishes.
                         }
                     }),
                 };
                 tasks.push(task);
             });
-            if (options.watch) {
-                const stopWatch = yield client_1.daemonClient.registerFileWatcher({
+            if (options.runBuildTargetDependencies) {
+                // If a all dependencies need to be rebuild on changes, then register with watcher
+                // and run through CLI, otherwise only the current project will rebuild.
+                const runBuild = () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    let childProcess = null;
+                    const whenReady = new Promise((resolve) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                        childProcess = (0, child_process_1.fork)(require.resolve('nx'), [
+                            'run',
+                            `${context.projectName}:${buildTarget.target}${buildTarget.configuration ? `:${buildTarget.configuration}` : ''}`,
+                        ], {
+                            cwd: context.root,
+                            stdio: 'inherit',
+                        });
+                        childProcess.once('exit', (code) => {
+                            if (code === 0)
+                                resolve({ success: true });
+                            // If process is killed due to current task being killed, then resolve with success.
+                            else
+                                resolve({ success: !!(currentTask === null || currentTask === void 0 ? void 0 : currentTask.killed) });
+                        });
+                    }));
+                    yield addToQueue(childProcess, whenReady);
+                    yield debouncedProcessQueue();
+                });
+                additionalExitHandler = yield client_1.daemonClient.registerFileWatcher({
                     watchProjects: [context.projectName],
                     includeDependentProjects: true,
                 }, (err, data) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                    var _j;
+                    var _g;
                     if (err === 'closed') {
                         devkit_1.logger.error(`Watch error: Daemon closed the connection`);
                         process.exit(1);
                     }
                     else if (err) {
-                        devkit_1.logger.error(`Watch error: ${(_j = err === null || err === void 0 ? void 0 : err.message) !== null && _j !== void 0 ? _j : 'Unknown'}`);
+                        devkit_1.logger.error(`Watch error: ${(_g = err === null || err === void 0 ? void 0 : err.message) !== null && _g !== void 0 ? _g : 'Unknown'}`);
                     }
                     else {
                         devkit_1.logger.info(`NX File change detected. Restarting...`);
-                        yield addToQueue();
-                        yield debouncedProcessQueue();
+                        yield runBuild();
                     }
                 }));
-                const stopAllTasks = (signal = 'SIGTERM') => {
-                    for (const task of tasks) {
-                        task.stop(signal);
+                yield runBuild(); // run first build
+            }
+            else {
+                // Otherwise, run the build executor, which will not run task dependencies.
+                // This is mostly fine for bundlers like webpack that should already watch for dependency libs.
+                // For tsc/swc or custom build commands, consider using `runBuildTargetDependencies` instead.
+                const output = yield (0, devkit_1.runExecutor)(buildTarget, Object.assign(Object.assign({}, options.buildTargetOptions), { watch: options.watch }), context);
+                while (true) {
+                    const event = yield output.next();
+                    yield addToQueue(null, Promise.resolve(event.value));
+                    yield debouncedProcessQueue();
+                    if (event.done || !options.watch) {
+                        break;
                     }
-                };
-                process.on('SIGTERM', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                    stopWatch();
-                    stopAllTasks('SIGTERM');
-                    process.exit(128 + 15);
-                }));
-                process.on('SIGINT', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                    stopWatch();
-                    stopAllTasks('SIGINT');
-                    process.exit(128 + 2);
-                }));
-                process.on('SIGHUP', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                    stopWatch();
-                    stopAllTasks('SIGHUP');
-                    process.exit(128 + 1);
-                }));
+                }
             }
-            yield addToQueue();
-            yield processQueue();
+            const stopAllTasks = (signal = 'SIGTERM') => {
+                additionalExitHandler === null || additionalExitHandler === void 0 ? void 0 : additionalExitHandler();
+                for (const task of tasks) {
+                    task.stop(signal);
+                }
+            };
+            process.on('SIGTERM', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                stopAllTasks('SIGTERM');
+                process.exit(128 + 15);
+            }));
+            process.on('SIGINT', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                stopAllTasks('SIGINT');
+                process.exit(128 + 2);
+            }));
+            process.on('SIGHUP', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                stopAllTasks('SIGHUP');
+                process.exit(128 + 1);
+            }));
         })))));
     });
 }
@@ -227,7 +229,7 @@ function getExecArgv(options) {
 }
 function calculateResolveMappings(context, options) {
     const parsed = (0, devkit_1.parseTargetString)(options.buildTarget, context.projectGraph);
-    const { dependencies } = (0, buildable_libs_utils_1.calculateProjectDependencies)(context.projectGraph, context.root, parsed.project, parsed.target, parsed.configuration);
+    const { dependencies } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, parsed.project, parsed.target, parsed.configuration);
     return dependencies.reduce((m, c) => {
         if (c.node.type !== 'npm' && c.outputs[0] != null) {
             m[c.name] = (0, devkit_1.joinPathFragments)(context.root, c.outputs[0]);
@@ -251,6 +253,13 @@ function runWaitUntilTargets(options, context) {
     })));
 }
 function getFileToRun(context, project, buildOptions, buildTargetExecutor) {
+    // If using run-commands or another custom executor, then user should set
+    // outputFileName, but we can try the default value that we use.
+    if (!(buildOptions === null || buildOptions === void 0 ? void 0 : buildOptions.outputPath) && !(buildOptions === null || buildOptions === void 0 ? void 0 : buildOptions.outputFileName)) {
+        const fallbackFile = path.join('dist', project.data.root, 'main.js');
+        devkit_1.logger.warn(`Build option ${chalk.bold('outputFileName')} not set for ${chalk.bold(project.name)}. Using fallback value of ${chalk.bold(fallbackFile)}.`);
+        return (0, path_1.join)(context.root, fallbackFile);
+    }
     let outputFileName = buildOptions.outputFileName;
     if (!outputFileName) {
         const fileName = `${path.parse(buildOptions.main).name}.js`;

package/src/executors/tsc/lib/batch/build-task-info-per-tsconfig-map.js

@@ -45,7 +45,7 @@ function createTaskInfo(taskName, taskOptions, context, tsConfig) {
         outputDir: taskOptions.outputPath,
         assets: taskOptions.assets,
     });
-    const { target: projectGraphNode, dependencies: buildableProjectNodeDependencies, } = (0, buildable_libs_utils_1.calculateProjectDependencies)(context.projectGraph, context.root, context.taskGraph.tasks[taskName].target.project, context.taskGraph.tasks[taskName].target.target, context.taskGraph.tasks[taskName].target.configuration);
+    const { target: projectGraphNode, dependencies: buildableProjectNodeDependencies, } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, context.taskGraph.tasks[taskName].target.project, context.taskGraph.tasks[taskName].target.target, context.taskGraph.tasks[taskName].target.configuration);
     return {
         task: taskName,
         options: taskOptions,

package/src/generators/library/library.js

@@ -77,6 +77,9 @@ function projectGenerator(tree, schema, destinationDir, filesDir) {
                 (0, devkit_1.joinPathFragments)(options.projectRoot, './src', 'index.' + (options.js ? 'js' : 'ts')),
             ]);
         }
+        if (options.bundler !== 'none') {
+            addBundlerDependencies(tree, options);
+        }
         if (!options.skipFormat) {
             yield (0, devkit_1.formatFiles)(tree);
         }
@@ -110,10 +113,12 @@ function addProject(tree, options, destinationDir) {
         };
         if (options.bundler === 'esbuild') {
             projectConfiguration.targets.build.options.generatePackageJson = true;
+            projectConfiguration.targets.build.options.format = ['cjs'];
         }
         if (options.bundler === 'rollup') {
             projectConfiguration.targets.build.options.project = `${options.projectRoot}/package.json`;
             projectConfiguration.targets.build.options.compiler = 'swc';
+            projectConfiguration.targets.build.options.format = ['cjs', 'esm'];
         }
         if (options.bundler === 'swc' && options.skipTypeCheck) {
             projectConfiguration.targets.build.options.skipTypeCheck = true;
@@ -163,6 +168,17 @@ function addLint(tree, options) {
     });
 }
 exports.addLint = addLint;
+function addBundlerDependencies(tree, options) {
+    (0, devkit_1.updateJson)(tree, `${options.projectRoot}/package.json`, (json) => {
+        if (options.bundler === 'tsc') {
+            json.dependencies = Object.assign(Object.assign({}, json.dependencies), { tslib: versions_1.tsLibVersion });
+        }
+        else if (options.bundler === 'swc') {
+            json.dependencies = Object.assign(Object.assign({}, json.dependencies), { '@swc/helpers': versions_1.swcHelpersVersion });
+        }
+        return json;
+    });
+}
 function updateTsConfig(tree, options) {
     (0, devkit_1.updateJson)(tree, (0, path_1.join)(options.projectRoot, 'tsconfig.json'), (json) => {
         if (options.strict) {
@@ -203,20 +219,15 @@ function createFiles(tree, options, filesDir) {
         (0, devkit_1.updateJson)(tree, packageJsonPath, (json) => {
             json.name = options.importPath;
             json.version = '0.0.1';
-            json.type = 'commonjs';
             // If the package is publishable, we should remove the private field.
             if (json.private && options.publishable) {
                 delete json.private;
             }
-            return json;
+            return Object.assign(Object.assign(Object.assign({}, json), { dependencies: Object.assign(Object.assign({}, json.dependencies), determineDependencies(options)) }), determineEntryFields(options));
         });
     }
     else {
-        (0, devkit_1.writeJson)(tree, packageJsonPath, {
-            name: options.importPath,
-            version: '0.0.1',
-            type: 'commonjs',
-        });
+        (0, devkit_1.writeJson)(tree, packageJsonPath, Object.assign({ name: options.importPath, version: '0.0.1', dependencies: determineDependencies(options) }, determineEntryFields(options)));
     }
     if (options.config === 'npm-scripts') {
         (0, devkit_1.updateJson)(tree, packageJsonPath, (json) => {
@@ -412,5 +423,68 @@ function createProjectTsConfigJson(tree, options) {
     };
     (0, devkit_1.writeJson)(tree, (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.json'), tsconfig);
 }
+function determineDependencies(options) {
+    switch (options.bundler) {
+        case 'tsc':
+            // importHelpers is true by default, so need to add tslib as a dependency.
+            return {
+                tslib: versions_1.tsLibVersion,
+            };
+        case 'swc':
+            // externalHelpers is true  by default, so need to add swc helpers as a dependency.
+            return {
+                '@swc/helpers': versions_1.swcHelpersVersion,
+            };
+        default: {
+            // In other cases (vite, rollup, esbuild), helpers are bundled so no need to add them as a dependency.
+            return {};
+        }
+    }
+}
+function determineEntryFields(options) {
+    switch (options.bundler) {
+        case 'tsc':
+            return {
+                type: 'commonjs',
+                main: './src/index.js',
+                typings: './src/index.d.ts',
+            };
+        case 'swc':
+            return {
+                type: 'commonjs',
+                main: './src/index.js',
+                typings: './src/index.d.ts',
+            };
+        case 'rollup':
+            return {
+                type: 'commonjs',
+                main: './index.cjs',
+                module: './index.js',
+                // typings is missing for rollup currently
+            };
+        case 'vite':
+            return {
+                // Since we're publishing both formats, skip the type field.
+                // Bundlers or Node will determine the entry point to use.
+                main: './index.js',
+                module: './index.mjs',
+                typings: './index.d.ts',
+            };
+        case 'esbuild':
+            // For libraries intended for Node, use CJS.
+            return {
+                type: 'commonjs',
+                main: './index.cjs',
+                // typings is missing for esbuild currently
+            };
+        default: {
+            return {
+                // CJS is the safest optional for now due to lack of support from some packages
+                // also setting `type: module` results in different resolution behavior (e.g. import 'foo' no longer resolves to 'foo/index.js')
+                type: 'commonjs',
+            };
+        }
+    }
+}
 exports.default = libraryGenerator;
 exports.librarySchematic = (0, devkit_1.convertNxGenerator)(libraryGenerator);

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

@@ -1,17 +1,28 @@
-import type { ProjectGraph, ProjectGraphProjectNode } from '@nx/devkit';
-import { ProjectGraphExternalNode } from '@nx/devkit';
+import type { ProjectGraph, ProjectGraphExternalNode, ProjectGraphProjectNode, TaskGraph } from '@nx/devkit';
 import type * as ts from 'typescript';
 export type DependentBuildableProjectNode = {
     name: string;
     outputs: string[];
     node: ProjectGraphProjectNode | ProjectGraphExternalNode;
 };
+export declare function calculateProjectBuildableDependencies(taskGraph: TaskGraph | undefined, projGraph: ProjectGraph, root: string, projectName: string, targetName: string, configurationName: string, shallow?: boolean): {
+    target: ProjectGraphProjectNode;
+    dependencies: DependentBuildableProjectNode[];
+    nonBuildableDependencies: string[];
+    topLevelDependencies: DependentBuildableProjectNode[];
+};
 export declare function calculateProjectDependencies(projGraph: ProjectGraph, root: string, projectName: string, targetName: string, configurationName: string, shallow?: boolean): {
     target: ProjectGraphProjectNode;
     dependencies: DependentBuildableProjectNode[];
     nonBuildableDependencies: string[];
     topLevelDependencies: DependentBuildableProjectNode[];
 };
+export declare function calculateDependenciesFromTaskGraph(taskGraph: TaskGraph, projectGraph: ProjectGraph, root: string, projectName: string, targetName: string, configurationName: string, shallow?: boolean): {
+    target: ProjectGraphProjectNode;
+    dependencies: DependentBuildableProjectNode[];
+    nonBuildableDependencies: string[];
+    topLevelDependencies: DependentBuildableProjectNode[];
+};
 /**
  * Util function to create tsconfig compilerOptions object with support for workspace libs paths.
  *

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

@@ -1,19 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateBuildableProjectPackageJsonDependencies = exports.updatePaths = exports.findMissingBuildDependencies = exports.checkDependentProjectsHaveBeenBuilt = exports.createTmpTsConfig = exports.computeCompilerOptionsPaths = exports.calculateProjectDependencies = void 0;
-const path_1 = require("path");
-const fileutils_1 = require("nx/src/utils/fileutils");
+exports.updateBuildableProjectPackageJsonDependencies = exports.updatePaths = exports.findMissingBuildDependencies = exports.checkDependentProjectsHaveBeenBuilt = exports.createTmpTsConfig = exports.computeCompilerOptionsPaths = exports.calculateDependenciesFromTaskGraph = exports.calculateProjectDependencies = exports.calculateProjectBuildableDependencies = void 0;
 const devkit_1 = require("@nx/devkit");
 const fs_1 = require("fs");
-const output_1 = require("nx/src/utils/output");
 const operators_1 = require("nx/src/project-graph/operators");
+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");
-let tsModule;
 function isBuildable(target, node) {
     return (node.data.targets &&
         node.data.targets[target] &&
         node.data.targets[target].executor !== '');
 }
+function calculateProjectBuildableDependencies(taskGraph, projGraph, root, projectName, targetName, configurationName, shallow) {
+    if (process.env.NX_BUILDABLE_LIBRARIES_TASK_GRAPH === 'true' && taskGraph) {
+        return calculateDependenciesFromTaskGraph(taskGraph, projGraph, root, projectName, targetName, configurationName, shallow);
+    }
+    return calculateProjectDependencies(projGraph, root, projectName, targetName, configurationName, shallow);
+}
+exports.calculateProjectBuildableDependencies = calculateProjectBuildableDependencies;
 function calculateProjectDependencies(projGraph, root, projectName, targetName, configurationName, shallow) {
     const target = projGraph.nodes[projectName];
     // gather the library dependencies
@@ -108,6 +114,101 @@ function readTsConfigWithRemappedPaths(tsConfig, generatedTsConfigPath, dependen
     }
     return generatedTsConfig;
 }
+function calculateDependenciesFromTaskGraph(taskGraph, projectGraph, root, projectName, targetName, configurationName, shallow) {
+    var _a;
+    const target = projectGraph.nodes[projectName];
+    const nonBuildableDependencies = [];
+    const topLevelDependencies = [];
+    const dependentTasks = collectDependentTasks(projectName, `${projectName}:${targetName}${configurationName ? `:${configurationName}` : ''}`, taskGraph, projectGraph, shallow);
+    const npmDependencies = collectNpmDependencies(projectName, projectGraph, !shallow ? dependentTasks : undefined);
+    const dependencies = [];
+    for (const [taskName, { isTopLevel }] of dependentTasks) {
+        let project = null;
+        const depTask = taskGraph.tasks[taskName];
+        const depProjectNode = (_a = projectGraph.nodes) === null || _a === void 0 ? void 0 : _a[depTask.target.project];
+        if ((depProjectNode === null || depProjectNode === void 0 ? void 0 : depProjectNode.type) !== 'lib') {
+            return null;
+        }
+        let outputs = (0, devkit_1.getOutputsForTargetAndConfiguration)(depTask, depProjectNode);
+        if (outputs.length === 0) {
+            nonBuildableDependencies.push(depTask.target.project);
+            continue;
+        }
+        const libPackageJsonPath = (0, path_1.join)(root, depProjectNode.data.root, 'package.json');
+        project = {
+            name: (0, fileutils_1.fileExists)(libPackageJsonPath)
+                ? (0, devkit_1.readJsonFile)(libPackageJsonPath).name // i.e. @workspace/mylib
+                : depTask.target.project,
+            outputs,
+            node: depProjectNode,
+        };
+        if (isTopLevel) {
+            topLevelDependencies.push(project);
+        }
+        dependencies.push(project);
+    }
+    for (const { project, isTopLevel } of npmDependencies) {
+        if (isTopLevel) {
+            topLevelDependencies.push(project);
+        }
+        dependencies.push(project);
+    }
+    dependencies.sort((a, b) => (a.name > b.name ? 1 : b.name > a.name ? -1 : 0));
+    return {
+        target,
+        dependencies,
+        nonBuildableDependencies,
+        topLevelDependencies,
+    };
+}
+exports.calculateDependenciesFromTaskGraph = calculateDependenciesFromTaskGraph;
+function collectNpmDependencies(projectName, projectGraph, dependentTasks, collectedPackages = new Set(), isTopLevel = true) {
+    const dependencies = projectGraph.dependencies[projectName]
+        .map((dep) => {
+        var _a, _b, _c;
+        const projectNode = (_b = (_a = projectGraph.nodes) === null || _a === void 0 ? void 0 : _a[dep.target]) !== null && _b !== void 0 ? _b : (_c = projectGraph.externalNodes) === null || _c === void 0 ? void 0 : _c[dep.target];
+        if ((projectNode === null || projectNode === void 0 ? void 0 : projectNode.type) !== 'npm' ||
+            collectedPackages.has(projectNode.data.packageName)) {
+            return null;
+        }
+        const project = {
+            name: projectNode.data.packageName,
+            outputs: [],
+            node: projectNode,
+        };
+        collectedPackages.add(project.name);
+        return { project, isTopLevel };
+    })
+        .filter((x) => !!x);
+    if (dependentTasks === null || dependentTasks === void 0 ? void 0 : dependentTasks.size) {
+        for (const [, { project: projectName }] of dependentTasks) {
+            dependencies.push(...collectNpmDependencies(projectName, projectGraph, undefined, collectedPackages, false));
+        }
+    }
+    return dependencies;
+}
+function collectDependentTasks(project, task, taskGraph, projectGraph, shallow, areTopLevelDeps = true, dependentTasks = new Map()) {
+    var _a;
+    for (const depTask of (_a = taskGraph.dependencies[task]) !== null && _a !== void 0 ? _a : []) {
+        if (dependentTasks.has(depTask)) {
+            if (!dependentTasks.get(depTask).isTopLevel && areTopLevelDeps) {
+                dependentTasks.get(depTask).isTopLevel = true;
+            }
+            continue;
+        }
+        const { project: depTaskProject } = (0, devkit_1.parseTargetString)(depTask, projectGraph);
+        if (depTaskProject !== project) {
+            dependentTasks.set(depTask, {
+                project: depTaskProject,
+                isTopLevel: areTopLevelDeps,
+            });
+        }
+        if (!shallow) {
+            collectDependentTasks(depTaskProject, depTask, taskGraph, projectGraph, shallow, depTaskProject === project && areTopLevelDeps, dependentTasks);
+        }
+    }
+    return dependentTasks;
+}
 /**
  * Util function to create tsconfig compilerOptions object with support for workspace libs paths.
  *

package/src/utils/check-dependencies.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkDependencies = void 0;
 const buildable_libs_utils_1 = require("./buildable-libs-utils");
 function checkDependencies(context, tsConfigPath) {
-    const { target, dependencies } = (0, buildable_libs_utils_1.calculateProjectDependencies)(context.projectGraph, context.root, context.projectName, context.targetName, context.configurationName);
+    const { target, dependencies } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, context.projectName, context.targetName, context.configurationName);
     const projectRoot = target.data.root;
     if (dependencies.length > 0) {
         return {

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findNpmDependencies = void 0;
 const path_1 = require("path");
-const file_utils_1 = require("nx/src/project-graph/file-utils");
+const configuration_1 = require("nx/src/config/configuration");
 const task_hasher_1 = require("nx/src/hasher/task-hasher");
 const devkit_1 = require("@nx/devkit");
 const fileutils_1 = require("nx/src/utils/fileutils");
@@ -44,7 +44,7 @@ function collectDependenciesFromFileMap(workspaceRoot, sourceProject, projectGra
     // Cannot read inputs if the target does not exist on the project.
     if (!sourceProject.data.targets[buildTarget])
         return;
-    const inputs = (0, task_hasher_1.getTargetInputs)((0, file_utils_1.readNxJson)(), sourceProject, buildTarget).selfInputs;
+    const inputs = (0, task_hasher_1.getTargetInputs)((0, configuration_1.readNxJson)(), sourceProject, buildTarget).selfInputs;
     const files = (0, task_hasher_1.filterUsingGlobPatterns)(sourceProject.data.root, projectFileMap[sourceProject.name] || [], inputs);
     for (const fileData of files) {
         if (!fileData.deps ||