@nx/js 0.0.0-pr-3-5e7ccde → 0.0.0-pr-29464-c4b160c

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "0.0.0-pr-3-5e7ccde",
+  "version": "0.0.0-pr-29464-c4b160c",
   "private": false,
   "description": "The JS plugin for Nx contains executors and generators that provide the best experience for developing JavaScript and TypeScript projects. ",
   "repository": {
@@ -39,8 +39,8 @@
     "@babel/preset-env": "^7.23.2",
     "@babel/preset-typescript": "^7.22.5",
     "@babel/runtime": "^7.22.6",
-    "@nx/devkit": "0.0.0-pr-3-5e7ccde",
-    "@nx/workspace": "0.0.0-pr-3-5e7ccde",
+    "@nx/devkit": "0.0.0-pr-29464-c4b160c",
+    "@nx/workspace": "0.0.0-pr-29464-c4b160c",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^3.1.0",

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

@@ -88,7 +88,7 @@ async function* nodeExecutor(options, context) {
                 start: async () => {
                     // Wait for build to finish.
                     const result = await buildResult;
-                    if (!result.success) {
+                    if (result && !result.success) {
                         // If in watch-mode, don't throw or else the process exits.
                         if (options.watch) {
                             if (!task.killed) {

package/src/generators/library/library.js

@@ -8,7 +8,6 @@ const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project
 const prompt_1 = require("@nx/devkit/src/generators/prompt");
 const target_defaults_utils_1 = require("@nx/devkit/src/generators/target-defaults-utils");
 const log_show_project_command_1 = require("@nx/devkit/src/utils/log-show-project-command");
-const find_matching_projects_1 = require("nx/src/utils/find-matching-projects");
 const path_1 = require("path");
 const generator_prompts_1 = require("../../utils/generator-prompts");
 const update_package_json_1 = require("../../utils/package-json/update-package-json");
@@ -22,9 +21,9 @@ const ts_config_1 = require("../../utils/typescript/ts-config");
 const ts_solution_setup_1 = require("../../utils/typescript/ts-solution-setup");
 const versions_1 = require("../../utils/versions");
 const init_1 = require("../init/init");
-const generator_1 = require("../setup-verdaccio/generator");
 const sort_fields_1 = require("../../utils/package-json/sort-fields");
 const get_import_path_1 = require("../../utils/get-import-path");
+const add_release_config_1 = require("./utils/add-release-config");
 const defaultOutputDirectory = 'dist';
 async function libraryGenerator(tree, schema) {
     return await libraryGeneratorInternal(tree, {
@@ -54,9 +53,6 @@ async function libraryGeneratorInternal(tree, schema) {
     if (!options.skipPackageJson) {
         tasks.push(addProjectDependencies(tree, options));
     }
-    if (options.publishable) {
-        tasks.push(await (0, generator_1.default)(tree, { ...options, skipFormat: true }));
-    }
     if (options.bundler === 'rollup') {
         const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/rollup', versions_1.nxVersion);
         await configurationGenerator(tree, {
@@ -151,9 +147,7 @@ async function libraryGeneratorInternal(tree, schema) {
         await (0, devkit_1.formatFiles)(tree);
     }
     if (options.publishable) {
-        tasks.push(() => {
-            logNxReleaseDocsInfo();
-        });
+        tasks.push(await (0, add_release_config_1.releaseTasks)(tree));
     }
     // Always run install to link packages.
     if (options.isUsingTsSolutionConfig) {
@@ -220,26 +214,12 @@ async function configureProject(tree, options) {
         }
     }
     if (options.publishable) {
-        if (!options.isUsingTsSolutionConfig) {
-            const packageRoot = (0, devkit_1.joinPathFragments)(defaultOutputDirectory, '{projectRoot}');
-            projectConfiguration.targets ??= {};
-            projectConfiguration.targets['nx-release-publish'] = {
-                options: {
-                    packageRoot,
-                },
-            };
-            projectConfiguration.release = {
-                version: {
-                    generatorOptions: {
-                        packageRoot,
-                        // using git tags to determine the current version is required here because
-                        // the version in the package root is overridden with every build
-                        currentVersionResolver: 'git-tag',
-                    },
-                },
-            };
+        if (options.isUsingTsSolutionConfig) {
+            await (0, add_release_config_1.addReleaseConfigForTsSolution)(tree, options.name, projectConfiguration);
+        }
+        else {
+            await (0, add_release_config_1.addReleaseConfigForNonTsSolution)(tree, options.name, projectConfiguration, defaultOutputDirectory);
         }
-        await addProjectToNxReleaseConfig(tree, options, projectConfiguration);
     }
     if (!options.useProjectJson) {
         // we want the package.json as clean as possible, with the bare minimum
@@ -930,96 +910,6 @@ function determineEntryFields(options) {
         }
     }
 }
-function projectsConfigMatchesProject(projectsConfig, project) {
-    if (!projectsConfig) {
-        return false;
-    }
-    if (typeof projectsConfig === 'string') {
-        projectsConfig = [projectsConfig];
-    }
-    const graph = {
-        [project.name]: project,
-    };
-    const matchingProjects = (0, find_matching_projects_1.findMatchingProjects)(projectsConfig, graph);
-    return matchingProjects.includes(project.name);
-}
-async function addProjectToNxReleaseConfig(tree, options, projectConfiguration) {
-    const nxJson = (0, devkit_1.readNxJson)(tree);
-    const addPreVersionCommand = () => {
-        const pmc = (0, devkit_1.getPackageManagerCommand)();
-        nxJson.release = {
-            ...nxJson.release,
-            version: {
-                preVersionCommand: `${pmc.dlx} nx run-many -t build`,
-                ...nxJson.release?.version,
-            },
-        };
-    };
-    if (!nxJson.release || (!nxJson.release.projects && !nxJson.release.groups)) {
-        // skip adding any projects configuration since the new project should be
-        // automatically included by nx release's default project detection logic
-        addPreVersionCommand();
-        (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
-        return;
-    }
-    const project = {
-        name: options.name,
-        type: 'lib',
-        data: {
-            root: projectConfiguration.root,
-            tags: projectConfiguration.tags,
-        },
-    };
-    if (projectsConfigMatchesProject(nxJson.release.projects, project)) {
-        devkit_1.output.log({
-            title: `Project already included in existing release configuration`,
-        });
-        addPreVersionCommand();
-        (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
-        return;
-    }
-    if (Array.isArray(nxJson.release.projects)) {
-        nxJson.release.projects.push(options.name);
-        addPreVersionCommand();
-        (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
-        devkit_1.output.log({
-            title: `Added project to existing release configuration`,
-        });
-    }
-    if (nxJson.release.groups) {
-        const allGroups = Object.entries(nxJson.release.groups);
-        for (const [name, group] of allGroups) {
-            if (projectsConfigMatchesProject(group.projects, project)) {
-                addPreVersionCommand();
-                (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
-                return `Project already included in existing release configuration for group ${name}`;
-            }
-        }
-        devkit_1.output.warn({
-            title: `Could not find a release group that includes ${options.name}`,
-            bodyLines: [
-                `Ensure that ${options.name} is included in a release group's "projects" list in nx.json so it can be published with "nx release"`,
-            ],
-        });
-        addPreVersionCommand();
-        (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
-        return;
-    }
-    if (typeof nxJson.release.projects === 'string') {
-        nxJson.release.projects = [nxJson.release.projects, options.name];
-        addPreVersionCommand();
-        (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
-        devkit_1.output.log({
-            title: `Added project to existing release configuration`,
-        });
-        return;
-    }
-}
-function logNxReleaseDocsInfo() {
-    devkit_1.output.log({
-        title: `📦 To learn how to publish this library, see https://nx.dev/core-features/manage-releases.`,
-    });
-}
 function findRootJestPreset(tree) {
     const ext = ['js', 'cjs', 'mjs'].find((ext) => tree.exists(`jest.preset.${ext}`));
     return ext ? `jest.preset.${ext}` : null;

package/src/generators/library/utils/add-release-config.d.ts

@@ -0,0 +1,11 @@
+import { GeneratorCallback, ProjectConfiguration, Tree } from '@nx/devkit';
+/**
+ * Adds release option in nx.json to build the project before versioning
+ */
+export declare function addReleaseConfigForTsSolution(tree: Tree, projectName: string, projectConfiguration: ProjectConfiguration): Promise<void>;
+/**
+ * Add release configuration for non-ts solution projects
+ * Add release option in project.json and add packageRoot to nx-release-publish target
+ */
+export declare function addReleaseConfigForNonTsSolution(tree: Tree, projectName: string, projectConfiguration: ProjectConfiguration, defaultOutputDirectory?: string): Promise<ProjectConfiguration>;
+export declare function releaseTasks(tree: Tree): Promise<GeneratorCallback>;

package/src/generators/library/utils/add-release-config.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addReleaseConfigForTsSolution = addReleaseConfigForTsSolution;
+exports.addReleaseConfigForNonTsSolution = addReleaseConfigForNonTsSolution;
+exports.releaseTasks = releaseTasks;
+const devkit_1 = require("@nx/devkit");
+const find_matching_projects_1 = require("nx/src/utils/find-matching-projects");
+const generator_1 = require("../../setup-verdaccio/generator");
+/**
+ * Adds release option in nx.json to build the project before versioning
+ */
+async function addReleaseConfigForTsSolution(tree, projectName, projectConfiguration) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPreVersionCommand = () => {
+        const pmc = (0, devkit_1.getPackageManagerCommand)();
+        nxJson.release = {
+            ...nxJson.release,
+            version: {
+                preVersionCommand: `${pmc.dlx} nx run-many -t build`,
+                ...nxJson.release?.version,
+            },
+        };
+    };
+    // if the release configuration does not exist, it will be created
+    if (!nxJson.release || (!nxJson.release.projects && !nxJson.release.groups)) {
+        // skip adding any projects configuration since the new project should be
+        // automatically included by nx release's default project detection logic
+        addPreVersionCommand();
+        (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
+        return;
+    }
+    const project = {
+        name: projectName,
+        type: 'lib',
+        data: {
+            root: projectConfiguration.root,
+            tags: projectConfiguration.tags,
+        },
+    };
+    // if the project is already included in the release configuration, it will not be added again
+    if (projectsConfigMatchesProject(nxJson.release.projects, project)) {
+        devkit_1.output.log({
+            title: `Project already included in existing release configuration`,
+        });
+        addPreVersionCommand();
+        (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
+        return;
+    }
+    // if the release configuration is a string, it will be converted to an array and added to it
+    if (Array.isArray(nxJson.release.projects)) {
+        nxJson.release.projects.push(projectName);
+        addPreVersionCommand();
+        (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
+        devkit_1.output.log({
+            title: `Added project to existing release configuration`,
+        });
+    }
+    if (nxJson.release.groups) {
+        const allGroups = Object.entries(nxJson.release.groups);
+        for (const [name, group] of allGroups) {
+            if (projectsConfigMatchesProject(group.projects, project)) {
+                addPreVersionCommand();
+                (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
+                devkit_1.output.log({
+                    title: `Project already included in existing release configuration for group ${name}`,
+                });
+                return;
+            }
+        }
+        devkit_1.output.warn({
+            title: `Could not find a release group that includes ${projectName}`,
+            bodyLines: [
+                `Ensure that ${projectName} is included in a release group's "projects" list in nx.json so it can be published with "nx release"`,
+            ],
+        });
+        addPreVersionCommand();
+        (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
+        return;
+    }
+    if (typeof nxJson.release.projects === 'string') {
+        nxJson.release.projects = [nxJson.release.projects, projectName];
+        addPreVersionCommand();
+        (0, devkit_1.writeJson)(tree, 'nx.json', nxJson);
+        devkit_1.output.log({
+            title: `Added project to existing release configuration`,
+        });
+        return;
+    }
+}
+/**
+ * Add release configuration for non-ts solution projects
+ * Add release option in project.json and add packageRoot to nx-release-publish target
+ */
+async function addReleaseConfigForNonTsSolution(tree, projectName, projectConfiguration, defaultOutputDirectory = 'dist') {
+    const packageRoot = (0, devkit_1.joinPathFragments)(defaultOutputDirectory, '{projectRoot}');
+    projectConfiguration.targets ??= {};
+    projectConfiguration.targets['nx-release-publish'] = {
+        options: {
+            packageRoot,
+        },
+    };
+    projectConfiguration.release = {
+        version: {
+            generatorOptions: {
+                packageRoot,
+                // using git tags to determine the current version is required here because
+                // the version in the package root is overridden with every build
+                currentVersionResolver: 'git-tag',
+                fallbackCurrentVersionResolver: 'disk',
+            },
+        },
+    };
+    await addReleaseConfigForTsSolution(tree, projectName, projectConfiguration);
+    return projectConfiguration;
+}
+function projectsConfigMatchesProject(projectsConfig, project) {
+    if (!projectsConfig) {
+        return false;
+    }
+    if (typeof projectsConfig === 'string') {
+        projectsConfig = [projectsConfig];
+    }
+    const graph = {
+        [project.name]: project,
+    };
+    const matchingProjects = (0, find_matching_projects_1.findMatchingProjects)(projectsConfig, graph);
+    return matchingProjects.includes(project.name);
+}
+async function releaseTasks(tree) {
+    return (0, devkit_1.runTasksInSerial)(await (0, generator_1.default)(tree, { skipFormat: true }), () => logNxReleaseDocsInfo());
+}
+function logNxReleaseDocsInfo() {
+    devkit_1.output.log({
+        title: `📦 To learn how to publish this library, see https://nx.dev/core-features/manage-releases.`,
+    });
+}

package/src/generators/release-version/release-version.js

@@ -191,7 +191,7 @@ To fix this you will either need to add a package.json file at that location, or
                         const releaseTagPattern = options.releaseGroup.releaseTagPattern;
                         latestMatchingGitTag = await (0, git_1.getLatestGitTagForPattern)(releaseTagPattern, {
                             projectName: project.name,
-                        });
+                        }, options.releaseGroup.releaseTagPatternCheckAllBranchesWhen);
                         if (!latestMatchingGitTag) {
                             if (options.fallbackCurrentVersionResolver === 'disk') {
                                 if (!currentVersionFromDisk &&

package/src/plugins/typescript/plugin.js

@@ -6,20 +6,28 @@ const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
 const minimatch_1 = require("minimatch");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const posix = require("node:path/posix");
 const file_hasher_1 = require("nx/src/hasher/file-hasher");
 // eslint-disable-next-line @typescript-eslint/no-restricted-imports
 const lock_file_1 = require("nx/src/plugins/js/lock-file/lock-file");
 const cache_directory_1 = require("nx/src/utils/cache-directory");
-const ts_config_1 = require("../../utils/typescript/ts-config");
 const util_1 = require("./util");
 const pmc = (0, devkit_1.getPackageManagerCommand)();
-function readTargetsCache(cachePath) {
-    return process.env.NX_CACHE_PROJECT_GRAPH !== 'false' && (0, node_fs_1.existsSync)(cachePath)
-        ? (0, devkit_1.readJsonFile)(cachePath)
-        : {};
+let tsConfigCache;
+const tsConfigCachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, 'tsconfig-files.hash');
+let cache;
+function readFromCache(cachePath) {
+    try {
+        return process.env.NX_CACHE_PROJECT_GRAPH !== 'false'
+            ? (0, devkit_1.readJsonFile)(cachePath)
+            : {};
+    }
+    catch {
+        return {};
+    }
 }
-function writeTargetsToCache(cachePath, results) {
-    (0, devkit_1.writeJsonFile)(cachePath, results);
+function writeToCache(cachePath, data) {
+    (0, devkit_1.writeJsonFile)(cachePath, data, { spaces: 0 });
 }
 /**
  * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
@@ -34,15 +42,32 @@ exports.createNodesV2 = [
     tsConfigGlob,
     async (configFilePaths, options, context) => {
         const optionsHash = (0, file_hasher_1.hashObject)(options);
-        const cachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `tsc-${optionsHash}.hash`);
-        const targetsCache = readTargetsCache(cachePath);
+        const targetsCachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `tsc-${optionsHash}.hash`);
+        const targetsCache = readFromCache(targetsCachePath);
+        cache = { fileHashes: {}, rawFiles: {}, isExternalProjectReference: {} };
+        initializeTsConfigCache(configFilePaths, context.workspaceRoot);
         const normalizedOptions = normalizePluginOptions(options);
-        const lockFileName = (0, lock_file_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
+        const { configFilePaths: validConfigFilePaths, hashes, projectRoots, } = await resolveValidConfigFilesAndHashes(configFilePaths, optionsHash, context);
         try {
-            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => createNodesInternal(configFile, options, context, lockFileName, targetsCache), configFilePaths, normalizedOptions, context);
+            return await (0, devkit_1.createNodesFromFiles)((configFilePath, options, context, idx) => {
+                const projectRoot = projectRoots[idx];
+                const hash = hashes[idx];
+                const cacheKey = `${hash}_${configFilePath}`;
+                targetsCache[cacheKey] ??= buildTscTargets((0, node_path_1.join)(context.workspaceRoot, configFilePath), projectRoot, options, context);
+                const { targets } = targetsCache[cacheKey];
+                return {
+                    projects: {
+                        [projectRoot]: {
+                            projectType: 'library',
+                            targets,
+                        },
+                    },
+                };
+            }, validConfigFilePaths, normalizedOptions, context);
         }
         finally {
-            writeTargetsToCache(cachePath, targetsCache);
+            writeToCache(targetsCachePath, targetsCache);
+            writeToCache(tsConfigCachePath, toRelativePaths(tsConfigCache, context.workspaceRoot));
         }
     },
 ];
@@ -50,28 +75,92 @@ exports.createNodes = [
     tsConfigGlob,
     async (configFilePath, options, context) => {
         devkit_1.logger.warn('`createNodes` is deprecated. Update your plugin to utilize createNodesV2 instead. In Nx 20, this will change to the createNodesV2 API.');
+        const projectRoot = (0, node_path_1.dirname)(configFilePath);
+        if (!checkIfConfigFileShouldBeProject(configFilePath, projectRoot, context)) {
+            return {};
+        }
         const normalizedOptions = normalizePluginOptions(options);
-        const lockFileName = (0, lock_file_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
-        return createNodesInternal(configFilePath, normalizedOptions, context, lockFileName, {});
+        cache = { fileHashes: {}, rawFiles: {}, isExternalProjectReference: {} };
+        initializeTsConfigCache([configFilePath], context.workspaceRoot);
+        const { targets } = buildTscTargets((0, node_path_1.join)(context.workspaceRoot, configFilePath), projectRoot, normalizedOptions, context);
+        writeToCache(tsConfigCachePath, toRelativePaths(tsConfigCache, context.workspaceRoot));
+        return {
+            projects: {
+                [projectRoot]: {
+                    projectType: 'library',
+                    targets,
+                },
+            },
+        };
     },
 ];
-async function createNodesInternal(configFilePath, options, context, lockFileName, targetsCache) {
-    const projectRoot = (0, node_path_1.dirname)(configFilePath);
-    const fullConfigPath = (0, devkit_1.joinPathFragments)(context.workspaceRoot, configFilePath);
+async function resolveValidConfigFilesAndHashes(configFilePaths, optionsHash, context) {
+    const lockFileHash = (0, file_hasher_1.hashFile)((0, node_path_1.join)(context.workspaceRoot, (0, lock_file_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot)))) ?? '';
+    const validConfigFilePaths = [];
+    const hashes = [];
+    const projectRoots = [];
+    for await (const configFilePath of configFilePaths) {
+        const projectRoot = (0, node_path_1.dirname)(configFilePath);
+        if (!checkIfConfigFileShouldBeProject(configFilePath, projectRoot, context)) {
+            continue;
+        }
+        projectRoots.push(projectRoot);
+        validConfigFilePaths.push(configFilePath);
+        hashes.push(await getConfigFileHash(configFilePath, context.workspaceRoot, projectRoot, optionsHash, lockFileHash));
+    }
+    return { configFilePaths: validConfigFilePaths, hashes, projectRoots };
+}
+/**
+ * The cache key is composed by:
+ * - hashes of the content of the relevant files that can affect what's inferred by the plugin:
+ *   - current config file
+ *   - config files extended by the current config file (recursively up to the root config file)
+ *   - referenced config files that are internal to the owning Nx project of the current config file,
+ *     or is a shallow external reference of the owning Nx project
+ *   - lock file
+ *   - project's package.json
+ * - hash of the plugin options
+ * - current config file path
+ */
+async function getConfigFileHash(configFilePath, workspaceRoot, projectRoot, optionsHash, lockFileHash) {
+    const fullConfigPath = (0, node_path_1.join)(workspaceRoot, configFilePath);
+    const tsConfig = retrieveTsConfigFromCache(fullConfigPath, workspaceRoot);
+    const extendedConfigFiles = getExtendedConfigFiles(tsConfig, workspaceRoot);
+    const internalReferencedFiles = resolveInternalProjectReferences(tsConfig, workspaceRoot, projectRoot);
+    const externalProjectReferences = resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, projectRoot);
+    let packageJson = null;
+    try {
+        packageJson = (0, devkit_1.readJsonFile)((0, node_path_1.join)(workspaceRoot, projectRoot, 'package.json'));
+    }
+    catch { }
+    return (0, file_hasher_1.hashArray)([
+        ...[
+            fullConfigPath,
+            ...extendedConfigFiles.files.sort(),
+            ...Object.keys(internalReferencedFiles).sort(),
+            ...Object.keys(externalProjectReferences).sort(),
+        ].map((file) => getFileHash(file, workspaceRoot)),
+        ...extendedConfigFiles.packages.sort(),
+        lockFileHash,
+        optionsHash,
+        ...(packageJson ? [(0, file_hasher_1.hashObject)(packageJson)] : []),
+    ]);
+}
+function checkIfConfigFileShouldBeProject(configFilePath, projectRoot, context) {
     // Do not create a project for the workspace root tsconfig files.
     if (projectRoot === '.') {
-        return {};
+        return false;
     }
     // Do not create a project if package.json and project.json isn't there.
     const siblingFiles = (0, node_fs_1.readdirSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot));
     if (!siblingFiles.includes('package.json') &&
         !siblingFiles.includes('project.json')) {
-        return {};
+        return false;
     }
     // Do not create a project if it's not a tsconfig.json and there is no tsconfig.json in the same directory
     if ((0, node_path_1.basename)(configFilePath) !== 'tsconfig.json' &&
         !siblingFiles.includes('tsconfig.json')) {
-        return {};
+        return false;
     }
     // Do not create project for Next.js projects since they are not compatible with
     // project references and typecheck will fail.
@@ -79,53 +168,14 @@ async function createNodesInternal(configFilePath, options, context, lockFileNam
         siblingFiles.includes('next.config.cjs') ||
         siblingFiles.includes('next.config.mjs') ||
         siblingFiles.includes('next.config.ts')) {
-        return {};
+        return false;
     }
-    /**
-     * The cache key is composed by:
-     * - hashes of the content of the relevant files that can affect what's inferred by the plugin:
-     *   - current config file
-     *   - config files extended by the current config file (recursively up to the root config file)
-     *   - referenced config files that are internal to the owning Nx project of the current config file, or is a shallow external reference of the owning Nx project
-     *   - lock file
-     * - hash of the plugin options
-     * - current config file path
-     */
-    const tsConfig = readCachedTsConfig(fullConfigPath);
-    const extendedConfigFiles = getExtendedConfigFiles(fullConfigPath, tsConfig);
-    const internalReferencedFiles = resolveInternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
-    const externalProjectReferences = resolveShallowExternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
-    const packageJsonPath = (0, devkit_1.joinPathFragments)(projectRoot, 'package.json');
-    const packageJson = (0, node_fs_1.existsSync)(packageJsonPath)
-        ? (0, devkit_1.readJsonFile)(packageJsonPath)
-        : null;
-    const nodeHash = (0, file_hasher_1.hashArray)([
-        ...[
-            fullConfigPath,
-            ...extendedConfigFiles.files,
-            ...Object.keys(internalReferencedFiles),
-            ...Object.keys(externalProjectReferences),
-            (0, node_path_1.join)(context.workspaceRoot, lockFileName),
-        ].map(file_hasher_1.hashFile),
-        (0, file_hasher_1.hashObject)(options),
-        ...(packageJson ? [(0, file_hasher_1.hashObject)(packageJson)] : []),
-    ]);
-    const cacheKey = `${nodeHash}_${configFilePath}`;
-    targetsCache[cacheKey] ??= buildTscTargets(fullConfigPath, projectRoot, options, context);
-    const { targets } = targetsCache[cacheKey];
-    return {
-        projects: {
-            [projectRoot]: {
-                projectType: 'library',
-                targets,
-            },
-        },
-    };
+    return true;
 }
 function buildTscTargets(configFilePath, projectRoot, options, context) {
     const targets = {};
     const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
-    const tsConfig = readCachedTsConfig(configFilePath);
+    const tsConfig = retrieveTsConfigFromCache(configFilePath, context.workspaceRoot);
     let internalProjectReferences;
     // Typecheck target
     if ((0, node_path_1.basename)(configFilePath) === 'tsconfig.json' && options.typecheck) {
@@ -196,7 +246,7 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
 function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferences, workspaceRoot, projectRoot) {
     const configFiles = new Set();
     const externalDependencies = ['typescript'];
-    const extendedConfigFiles = getExtendedConfigFiles(configFilePath, tsConfig);
+    const extendedConfigFiles = getExtendedConfigFiles(tsConfig, workspaceRoot);
     extendedConfigFiles.files.forEach((configPath) => {
         configFiles.add(configPath);
     });
@@ -294,7 +344,9 @@ function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspa
                 outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.options.outDir, relativeRootDir, `*.tsbuildinfo`), workspaceRoot, projectRoot));
             }
         }
-        else if (config.fileNames.length) {
+        else if (config.raw?.include?.length ||
+            config.raw?.files?.length ||
+            (!config.raw?.include && !config.raw?.files)) {
             // tsc produce files in place when no outDir or outFile is set
             outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.js'));
             outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.cjs'));
@@ -407,23 +459,17 @@ function pathToInputOrOutput(path, workspaceRoot, projectRoot) {
     }
     return (0, devkit_1.joinPathFragments)('{projectRoot}', pathRelativeToProjectRoot);
 }
-function getExtendedConfigFiles(tsConfigPath, tsConfig) {
+function getExtendedConfigFiles(tsConfig, workspaceRoot) {
     const extendedConfigFiles = new Set();
     const extendedExternalPackages = new Set();
-    let currentConfigPath = tsConfigPath;
-    let currentConfig = tsConfig;
-    while (currentConfig.raw?.extends) {
-        const extendedConfigPath = resolveExtendedTsConfigPath(currentConfig.raw.extends, (0, node_path_1.dirname)(currentConfigPath));
-        if (!extendedConfigPath) {
-            break;
-        }
-        if (extendedConfigPath.externalPackage) {
-            extendedExternalPackages.add(extendedConfigPath.externalPackage);
+    let currentExtendedConfigFile = tsConfig.extendedConfigFile;
+    while (currentExtendedConfigFile) {
+        if (currentExtendedConfigFile.externalPackage) {
+            extendedExternalPackages.add(currentExtendedConfigFile.externalPackage);
             break;
         }
-        extendedConfigFiles.add(extendedConfigPath.filePath);
-        currentConfig = readCachedTsConfig(extendedConfigPath.filePath);
-        currentConfigPath = extendedConfigPath.filePath;
+        extendedConfigFiles.add(currentExtendedConfigFile.filePath);
+        currentExtendedConfigFile = retrieveTsConfigFromCache(currentExtendedConfigFile.filePath, workspaceRoot).extendedConfigFile;
     }
     return {
         files: Array.from(extendedConfigFiles),
@@ -431,27 +477,31 @@ function getExtendedConfigFiles(tsConfigPath, tsConfig) {
     };
 }
 function resolveInternalProjectReferences(tsConfig, workspaceRoot, projectRoot, projectReferences = {}) {
-    walkProjectReferences(tsConfig, workspaceRoot, projectRoot, (configPath, config) => {
-        if (isExternalProjectReference(configPath, workspaceRoot, projectRoot)) {
-            return false;
+    if (!tsConfig.projectReferences?.length) {
+        return {};
+    }
+    for (const ref of tsConfig.projectReferences) {
+        let refConfigPath = ref.path;
+        if (projectReferences[refConfigPath]) {
+            // Already resolved
+            continue;
         }
-        else {
-            projectReferences[configPath] = config;
+        if (!(0, node_fs_1.existsSync)(refConfigPath)) {
+            // the referenced tsconfig doesn't exist, ignore it
+            continue;
         }
-    });
-    return projectReferences;
-}
-function resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, projectRoot, projectReferences = {}) {
-    walkProjectReferences(tsConfig, workspaceRoot, projectRoot, (configPath, config) => {
-        if (isExternalProjectReference(configPath, workspaceRoot, projectRoot)) {
-            projectReferences[configPath] = config;
+        if (isExternalProjectReference(refConfigPath, workspaceRoot, projectRoot)) {
+            continue;
         }
-        return false;
-    });
+        if (!refConfigPath.endsWith('.json')) {
+            refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
+        }
+        projectReferences[refConfigPath] = retrieveTsConfigFromCache(refConfigPath, workspaceRoot);
+        resolveInternalProjectReferences(projectReferences[refConfigPath], workspaceRoot, projectRoot, projectReferences);
+    }
     return projectReferences;
 }
-function walkProjectReferences(tsConfig, workspaceRoot, projectRoot, visitor, // false stops recursion
-projectReferences = {}) {
+function resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, projectRoot, projectReferences = {}) {
     if (!tsConfig.projectReferences?.length) {
         return projectReferences;
     }
@@ -465,13 +515,11 @@ projectReferences = {}) {
             // the referenced tsconfig doesn't exist, ignore it
             continue;
         }
-        if (!refConfigPath.endsWith('.json')) {
-            refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
-        }
-        const refTsConfig = readCachedTsConfig(refConfigPath);
-        const result = visitor(refConfigPath, refTsConfig);
-        if (result !== false) {
-            walkProjectReferences(refTsConfig, workspaceRoot, projectRoot, visitor);
+        if (isExternalProjectReference(refConfigPath, workspaceRoot, projectRoot)) {
+            if (!refConfigPath.endsWith('.json')) {
+                refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
+            }
+            projectReferences[refConfigPath] = retrieveTsConfigFromCache(refConfigPath, workspaceRoot);
         }
     }
     return projectReferences;
@@ -497,7 +545,7 @@ function hasExternalProjectReferences(tsConfigPath, tsConfig, workspaceRoot, pro
         if (!refConfigPath.endsWith('.json')) {
             refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
         }
-        const refTsConfig = readCachedTsConfig(refConfigPath);
+        const refTsConfig = retrieveTsConfigFromCache(refConfigPath, workspaceRoot);
         const result = hasExternalProjectReferences(refConfigPath, refTsConfig, workspaceRoot, projectRoot, seen);
         if (result) {
             return true;
@@ -506,21 +554,28 @@ function hasExternalProjectReferences(tsConfigPath, tsConfig, workspaceRoot, pro
     return false;
 }
 function isExternalProjectReference(refTsConfigPath, workspaceRoot, projectRoot) {
+    const relativePath = posix.relative(workspaceRoot, refTsConfigPath);
+    if (cache.isExternalProjectReference[relativePath] !== undefined) {
+        return cache.isExternalProjectReference[relativePath];
+    }
     const absoluteProjectRoot = (0, node_path_1.join)(workspaceRoot, projectRoot);
     let currentPath = getTsConfigDirName(refTsConfigPath);
     if ((0, node_path_1.relative)(absoluteProjectRoot, currentPath).startsWith('..')) {
         // it's outside of the project root, so it's an external project reference
+        cache.isExternalProjectReference[relativePath] = true;
         return true;
     }
     while (currentPath !== absoluteProjectRoot) {
         if ((0, node_fs_1.existsSync)((0, node_path_1.join)(currentPath, 'package.json')) ||
             (0, node_fs_1.existsSync)((0, node_path_1.join)(currentPath, 'project.json'))) {
             // it's inside a nested project root, so it's and external project reference
+            cache.isExternalProjectReference[relativePath] = true;
             return true;
         }
         currentPath = (0, node_path_1.dirname)(currentPath);
     }
     // it's inside the project root, so it's an internal project reference
+    cache.isExternalProjectReference[relativePath] = false;
     return false;
 }
 function getTsConfigDirName(tsConfigPath) {
@@ -528,19 +583,79 @@ function getTsConfigDirName(tsConfigPath) {
         ? (0, node_path_1.dirname)(tsConfigPath)
         : (0, node_path_1.normalize)(tsConfigPath);
 }
-const tsConfigCache = new Map();
-function readCachedTsConfig(tsConfigPath) {
-    const cacheKey = getTsConfigCacheKey(tsConfigPath);
-    if (tsConfigCache.has(cacheKey)) {
-        return tsConfigCache.get(cacheKey);
-    }
-    const tsConfig = (0, ts_config_1.readTsConfig)(tsConfigPath);
-    tsConfigCache.set(cacheKey, tsConfig);
-    return tsConfig;
+function retrieveTsConfigFromCache(tsConfigPath, workspaceRoot) {
+    const relativePath = posix.relative(workspaceRoot, tsConfigPath);
+    // we don't need to check the hash if it's in the cache, because we've already
+    // checked it when we initially populated the cache
+    return tsConfigCache[relativePath]
+        ? tsConfigCache[relativePath].data
+        : readTsConfigAndCache(tsConfigPath, workspaceRoot);
+}
+function initializeTsConfigCache(configFilePaths, workspaceRoot) {
+    tsConfigCache = toAbsolutePaths(readFromCache(tsConfigCachePath), workspaceRoot);
+    // ensure hashes are checked and the cache is invalidated and populated as needed
+    for (const configFilePath of configFilePaths) {
+        const fullConfigPath = (0, node_path_1.join)(workspaceRoot, configFilePath);
+        readTsConfigAndCache(fullConfigPath, workspaceRoot);
+    }
+}
+function readTsConfigAndCache(tsConfigPath, workspaceRoot) {
+    const relativePath = posix.relative(workspaceRoot, tsConfigPath);
+    const hash = getFileHash(tsConfigPath, workspaceRoot);
+    let extendedFilesHash;
+    if (tsConfigCache[relativePath] &&
+        tsConfigCache[relativePath].hash === hash) {
+        extendedFilesHash = getExtendedFilesHash(tsConfigCache[relativePath].data.extendedConfigFile, workspaceRoot);
+        if (tsConfigCache[relativePath].extendedFilesHash === extendedFilesHash) {
+            return tsConfigCache[relativePath].data;
+        }
+    }
+    const tsConfig = readTsConfig(tsConfigPath, workspaceRoot);
+    const extendedConfigFile = tsConfig.raw?.extends
+        ? resolveExtendedTsConfigPath(tsConfig.raw.extends, (0, node_path_1.dirname)(tsConfigPath))
+        : null;
+    extendedFilesHash ??= getExtendedFilesHash(extendedConfigFile, workspaceRoot);
+    tsConfigCache[relativePath] = {
+        data: {
+            options: tsConfig.options,
+            projectReferences: tsConfig.projectReferences,
+            raw: tsConfig.raw,
+            extendedConfigFile: extendedConfigFile ?? null,
+        },
+        hash,
+        extendedFilesHash,
+    };
+    return tsConfigCache[relativePath].data;
+}
+function getExtendedFilesHash(extendedConfigFile, workspaceRoot) {
+    const hashes = [];
+    if (!extendedConfigFile) {
+        return '';
+    }
+    if (extendedConfigFile.externalPackage) {
+        hashes.push(extendedConfigFile.externalPackage);
+    }
+    else if (extendedConfigFile.filePath) {
+        hashes.push(getFileHash(extendedConfigFile.filePath, workspaceRoot));
+        hashes.push(getExtendedFilesHash(readTsConfigAndCache(extendedConfigFile.filePath, workspaceRoot)
+            .extendedConfigFile, workspaceRoot));
+    }
+    return hashes.join('|');
 }
-function getTsConfigCacheKey(tsConfigPath) {
-    const timestamp = (0, node_fs_1.statSync)(tsConfigPath).mtimeMs;
-    return `${tsConfigPath}-${timestamp}`;
+let ts;
+function readTsConfig(tsConfigPath, workspaceRoot) {
+    if (!ts) {
+        ts = require('typescript');
+    }
+    const tsSys = {
+        ...ts.sys,
+        readFile: (path) => readFile(path, workspaceRoot),
+        readDirectory: () => [],
+    };
+    const readResult = ts.readConfigFile(tsConfigPath, tsSys.readFile);
+    // read with a custom host that won't read directories which is only used
+    // to identify the filenames included in the program, which we won't use
+    return ts.parseJsonConfigFileContent(readResult.config, tsSys, (0, node_path_1.dirname)(tsConfigPath));
 }
 function normalizePluginOptions(pluginOptions = {}) {
     const defaultTypecheckTargetName = 'typecheck';
@@ -600,3 +715,83 @@ function resolveExtendedTsConfigPath(tsConfigPath, directory) {
         return null;
     }
 }
+function getFileHash(filePath, workspaceRoot) {
+    const relativePath = posix.relative(workspaceRoot, filePath);
+    if (!cache.fileHashes[relativePath]) {
+        const content = readFile(filePath, workspaceRoot);
+        cache.fileHashes[relativePath] = (0, file_hasher_1.hashArray)([content]);
+    }
+    return cache.fileHashes[relativePath];
+}
+function readFile(filePath, workspaceRoot) {
+    const relativePath = posix.relative(workspaceRoot, filePath);
+    if (!cache.rawFiles[relativePath]) {
+        const content = (0, node_fs_1.readFileSync)(filePath, 'utf8');
+        cache.rawFiles[relativePath] = content;
+    }
+    return cache.rawFiles[relativePath];
+}
+function toAbsolutePaths(cache, workspaceRoot) {
+    const updatedCache = {};
+    for (const [key, { data, extendedFilesHash, hash }] of Object.entries(cache)) {
+        updatedCache[key] = {
+            data: {
+                options: { noEmit: data.options.noEmit },
+                extendedConfigFile: data.extendedConfigFile,
+            },
+            extendedFilesHash,
+            hash,
+        };
+        if (data.options.rootDir) {
+            updatedCache[key].data.options.rootDir = (0, node_path_1.join)(workspaceRoot, data.options.rootDir);
+        }
+        if (data.options.outDir) {
+            updatedCache[key].data.options.outDir = (0, node_path_1.join)(workspaceRoot, data.options.outDir);
+        }
+        if (data.options.outFile) {
+            updatedCache[key].data.options.outFile = (0, node_path_1.join)(workspaceRoot, data.options.outFile);
+        }
+        if (data.options.tsBuildInfoFile) {
+            updatedCache[key].data.options.tsBuildInfoFile = (0, node_path_1.join)(workspaceRoot, data.options.tsBuildInfoFile);
+        }
+        if (data.extendedConfigFile?.filePath) {
+            updatedCache[key].data.extendedConfigFile.filePath = (0, node_path_1.join)(workspaceRoot, data.extendedConfigFile.filePath);
+        }
+        if (data.projectReferences) {
+            updatedCache[key].data.projectReferences = data.projectReferences.map((ref) => ({ ...ref, path: (0, node_path_1.join)(workspaceRoot, ref.path) }));
+        }
+    }
+    return updatedCache;
+}
+function toRelativePaths(cache, workspaceRoot) {
+    const updatedCache = {};
+    for (const [key, { data, extendedFilesHash, hash }] of Object.entries(cache)) {
+        updatedCache[key] = {
+            data: {
+                options: { noEmit: data.options.noEmit },
+                extendedConfigFile: data.extendedConfigFile,
+            },
+            extendedFilesHash,
+            hash,
+        };
+        if (data.options.rootDir) {
+            updatedCache[key].data.options.rootDir = posix.relative(workspaceRoot, data.options.rootDir);
+        }
+        if (data.options.outDir) {
+            updatedCache[key].data.options.outDir = posix.relative(workspaceRoot, data.options.outDir);
+        }
+        if (data.options.outFile) {
+            updatedCache[key].data.options.outFile = posix.relative(workspaceRoot, data.options.outFile);
+        }
+        if (data.options.tsBuildInfoFile) {
+            updatedCache[key].data.options.tsBuildInfoFile = posix.relative(workspaceRoot, data.options.tsBuildInfoFile);
+        }
+        if (data.extendedConfigFile?.filePath) {
+            updatedCache[key].data.extendedConfigFile.filePath = posix.relative(workspaceRoot, data.extendedConfigFile.filePath);
+        }
+        if (data.projectReferences) {
+            updatedCache[key].data.projectReferences = data.projectReferences.map((ref) => ({ ...ref, path: posix.relative(workspaceRoot, ref.path) }));
+        }
+    }
+    return updatedCache;
+}

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/swc/add-swc-config.d.ts

@@ -1,4 +1,4 @@
 import { type Tree } from '@nx/devkit';
 export declare const defaultExclude: string[];
-export declare function addSwcConfig(tree: Tree, projectDir: string, type?: 'commonjs' | 'es6', supportTsx?: boolean): void;
+export declare function addSwcConfig(tree: Tree, projectDir: string, type?: 'commonjs' | 'es6', supportTsx?: boolean, swcName?: string, additionalExcludes?: string[]): void;
 export declare function addSwcTestConfig(tree: Tree, projectDir: string, type?: 'commonjs' | 'es6', supportTsx?: boolean): void;

package/src/utils/swc/add-swc-config.js

@@ -43,11 +43,11 @@ const swcOptionsString = (type = 'commonjs', exclude, supportTsx) => `{
   "exclude": ${JSON.stringify(exclude)}
 }
 `;
-function addSwcConfig(tree, projectDir, type = 'commonjs', supportTsx = false) {
-    const swcrcPath = (0, path_1.join)(projectDir, '.swcrc');
+function addSwcConfig(tree, projectDir, type = 'commonjs', supportTsx = false, swcName = '.swcrc', additionalExcludes = []) {
+    const swcrcPath = (0, path_1.join)(projectDir, swcName);
     if (tree.exists(swcrcPath))
         return;
-    tree.write(swcrcPath, swcOptionsString(type, exports.defaultExclude, supportTsx));
+    tree.write(swcrcPath, swcOptionsString(type, [...exports.defaultExclude, ...additionalExcludes], supportTsx));
 }
 function addSwcTestConfig(tree, projectDir, type = 'commonjs', supportTsx = false) {
     const swcrcPath = (0, path_1.join)(projectDir, '.spec.swcrc');