@nx/js 20.0.0 → 20.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "20.0.0",
+  "version": "20.0.2",
   "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": "20.0.0",
-    "@nx/workspace": "20.0.0",
+    "@nx/devkit": "20.0.2",
+    "@nx/workspace": "20.0.2",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^2.8.0",

package/src/executors/node/lib/kill-tree.js

@@ -20,7 +20,7 @@ async function killTree(pid, signal) {
         switch (process.platform) {
             case 'win32':
                 (0, child_process_1.exec)('taskkill /pid ' + pid + ' /T /F', {
-                    windowsHide: true,
+                    windowsHide: false,
                 }, (error) => {
                     // Ignore Fatal errors (128) because it might be due to the process already being killed.
                     // On Linux/Mac we can check ESRCH (no such process), but on Windows we can't.
@@ -30,7 +30,7 @@ async function killTree(pid, signal) {
             case 'darwin':
                 buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
                     return (0, child_process_1.spawn)('pgrep', ['-P', parentPid], {
-                        windowsHide: true,
+                        windowsHide: false,
                     });
                 }, function () {
                     killAll(tree, signal, callback);
@@ -39,7 +39,7 @@ async function killTree(pid, signal) {
             default: // Linux
                 buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
                     return (0, child_process_1.spawn)('ps', ['-o', 'pid', '--no-headers', '--ppid', parentPid], {
-                        windowsHide: true,
+                        windowsHide: false,
                     });
                 }, function () {
                     killAll(tree, signal, callback);

package/src/executors/release-publish/release-publish.impl.js

@@ -96,7 +96,7 @@ Please update the local dependency on "${depName}" to be a valid semantic versio
                 env: processEnv(true),
                 cwd: context.root,
                 stdio: ['ignore', 'pipe', 'pipe'],
-                windowsHide: true,
+                windowsHide: false,
             });
             const resultJson = JSON.parse(result.toString());
             const distTags = resultJson['dist-tags'] || {};
@@ -117,7 +117,7 @@ Please update the local dependency on "${depName}" to be a valid semantic versio
                             env: processEnv(true),
                             cwd: context.root,
                             stdio: 'ignore',
-                            windowsHide: true,
+                            windowsHide: false,
                         });
                         console.log(`Added the dist-tag ${tag} to v${currentVersion} for registry ${registry}.\n`);
                     }
@@ -204,7 +204,7 @@ Please update the local dependency on "${depName}" to be a valid semantic versio
             env: processEnv(true),
             cwd: context.root,
             stdio: ['ignore', 'pipe', 'pipe'],
-            windowsHide: true,
+            windowsHide: false,
         });
         /**
          * We cannot JSON.parse the output directly because if the user is using lifecycle scripts, npm/pnpm will mix its publish output with the JSON output all on stdout.

package/src/executors/verdaccio/verdaccio.impl.js

@@ -38,12 +38,12 @@ async function verdaccioExecutor(options, context) {
     }
     const cleanupFunctions = options.location === 'none' ? [] : [setupNpm(options), setupYarn(options)];
     const processExitListener = (signal) => {
-        if (childProcess) {
-            childProcess.kill(signal);
-        }
         for (const fn of cleanupFunctions) {
             fn();
         }
+        if (childProcess) {
+            childProcess.kill(signal);
+        }
     };
     process.on('exit', processExitListener);
     process.on('SIGTERM', processExitListener);
@@ -113,7 +113,7 @@ function createVerdaccioOptions(options, workspaceRoot) {
 }
 function setupNpm(options) {
     try {
-        (0, child_process_1.execSync)('npm --version', { env, windowsHide: true });
+        (0, child_process_1.execSync)('npm --version', { env, windowsHide: false });
     }
     catch (e) {
         return () => { };
@@ -124,13 +124,13 @@ function setupNpm(options) {
         scopes.forEach((scope) => {
             const registryName = scope ? `${scope}:registry` : 'registry';
             try {
-                npmRegistryPaths.push((0, child_process_1.execSync)(`npm config get ${registryName} --location ${options.location}`, { env, windowsHide: true })
+                npmRegistryPaths.push((0, child_process_1.execSync)(`npm config get ${registryName} --location ${options.location}`, { env, windowsHide: false })
                     ?.toString()
                     ?.trim()
                     ?.replace('\u001b[2K\u001b[1G', '') // strip out ansi codes
                 );
-                (0, child_process_1.execSync)(`npm config set ${registryName} http://localhost:${options.port}/ --location ${options.location}`, { env, windowsHide: true });
-                (0, child_process_1.execSync)(`npm config set //localhost:${options.port}/:_authToken="secretVerdaccioToken" --location ${options.location}`, { env, windowsHide: true });
+                (0, child_process_1.execSync)(`npm config set ${registryName} http://localhost:${options.port}/ --location ${options.location}`, { env, windowsHide: false });
+                (0, child_process_1.execSync)(`npm config set //localhost:${options.port}/:_authToken="secretVerdaccioToken" --location ${options.location}`, { env, windowsHide: false });
                 devkit_1.logger.info(`Set npm ${registryName} to http://localhost:${options.port}/`);
             }
             catch (e) {
@@ -139,7 +139,7 @@ function setupNpm(options) {
         });
         return () => {
             try {
-                const currentNpmRegistryPath = (0, child_process_1.execSync)(`npm config get registry --location ${options.location}`, { env, windowsHide: true })
+                const currentNpmRegistryPath = (0, child_process_1.execSync)(`npm config get registry --location ${options.location}`, { env, windowsHide: false })
                     ?.toString()
                     ?.trim()
                     ?.replace('\u001b[2K\u001b[1G', ''); // strip out ansi codes
@@ -147,18 +147,18 @@ function setupNpm(options) {
                     const registryName = scope ? `${scope}:registry` : 'registry';
                     if (npmRegistryPaths[index] &&
                         currentNpmRegistryPath.includes('localhost')) {
-                        (0, child_process_1.execSync)(`npm config set ${registryName} ${npmRegistryPaths[index]} --location ${options.location}`, { env, windowsHide: true });
+                        (0, child_process_1.execSync)(`npm config set ${registryName} ${npmRegistryPaths[index]} --location ${options.location}`, { env, windowsHide: false });
                         devkit_1.logger.info(`Reset npm ${registryName} to ${npmRegistryPaths[index]}`);
                     }
                     else {
                         (0, child_process_1.execSync)(`npm config delete ${registryName} --location ${options.location}`, {
                             env,
-                            windowsHide: true,
+                            windowsHide: false,
                         });
                         devkit_1.logger.info('Cleared custom npm registry');
                     }
                 });
-                (0, child_process_1.execSync)(`npm config delete //localhost:${options.port}/:_authToken  --location ${options.location}`, { env, windowsHide: true });
+                (0, child_process_1.execSync)(`npm config delete //localhost:${options.port}/:_authToken  --location ${options.location}`, { env, windowsHide: false });
             }
             catch (e) {
                 throw new Error(`Failed to reset npm registry: ${e.message}`);
@@ -173,17 +173,17 @@ function getYarnUnsafeHttpWhitelist(isYarnV1) {
     return !isYarnV1
         ? new Set(JSON.parse((0, child_process_1.execSync)(`yarn config get unsafeHttpWhitelist --json`, {
             env,
-            windowsHide: true,
+            windowsHide: false,
         }).toString()))
         : null;
 }
 function setYarnUnsafeHttpWhitelist(currentWhitelist, options) {
     if (currentWhitelist.size > 0) {
-        (0, child_process_1.execSync)(`yarn config set unsafeHttpWhitelist --json '${JSON.stringify(Array.from(currentWhitelist))}'` + (options.location === 'user' ? ' --home' : ''), { env, windowsHide: true });
+        (0, child_process_1.execSync)(`yarn config set unsafeHttpWhitelist --json '${JSON.stringify(Array.from(currentWhitelist))}'` + (options.location === 'user' ? ' --home' : ''), { env, windowsHide: false });
     }
     else {
         (0, child_process_1.execSync)(`yarn config unset unsafeHttpWhitelist` +
-            (options.location === 'user' ? ' --home' : ''), { env, windowsHide: true });
+            (options.location === 'user' ? ' --home' : ''), { env, windowsHide: false });
     }
 }
 function setupYarn(options) {
@@ -192,7 +192,9 @@ function setupYarn(options) {
     const scopes = ['', ...(options.scopes || [])];
     try {
         isYarnV1 =
-            (0, semver_1.major)((0, child_process_1.execSync)('yarn --version', { env, windowsHide: true }).toString().trim()) === 1;
+            (0, semver_1.major)((0, child_process_1.execSync)('yarn --version', { env, windowsHide: false })
+                .toString()
+                .trim()) === 1;
     }
     catch {
         // This would fail if yarn is not installed which is okay
@@ -204,14 +206,14 @@ function setupYarn(options) {
             const scopeName = scope ? `${scope}:` : '';
             yarnRegistryPaths.push((0, child_process_1.execSync)(`yarn config get ${scopeName}${registryConfigName}`, {
                 env,
-                windowsHide: true,
+                windowsHide: false,
             })
                 ?.toString()
                 ?.trim()
                 ?.replace('\u001b[2K\u001b[1G', '') // strip out ansi codes
             );
             (0, child_process_1.execSync)(`yarn config set ${scopeName}${registryConfigName} http://localhost:${options.port}/` +
-                (options.location === 'user' ? ' --home' : ''), { env, windowsHide: true });
+                (options.location === 'user' ? ' --home' : ''), { env, windowsHide: false });
             devkit_1.logger.info(`Set yarn ${scopeName}registry to http://localhost:${options.port}/`);
         });
         const currentWhitelist = getYarnUnsafeHttpWhitelist(isYarnV1);
@@ -224,7 +226,7 @@ function setupYarn(options) {
         }
         return () => {
             try {
-                const currentYarnRegistryPath = (0, child_process_1.execSync)(`yarn config get ${registryConfigName}`, { env, windowsHide: true })
+                const currentYarnRegistryPath = (0, child_process_1.execSync)(`yarn config get ${registryConfigName}`, { env, windowsHide: false })
                     ?.toString()
                     ?.trim()
                     ?.replace('\u001b[2K\u001b[1G', ''); // strip out ansi codes
@@ -237,13 +239,13 @@ function setupYarn(options) {
                         (0, child_process_1.execSync)(`yarn config set ${registryName} ${yarnRegistryPaths[index]}` +
                             (options.location === 'user' ? ' --home' : ''), {
                             env,
-                            windowsHide: true,
+                            windowsHide: false,
                         });
                         devkit_1.logger.info(`Reset yarn ${registryName} to ${yarnRegistryPaths[index]}`);
                     }
                     else {
                         (0, child_process_1.execSync)(`yarn config ${isYarnV1 ? 'delete' : 'unset'} ${registryName}` +
-                            (options.location === 'user' ? ' --home' : ''), { env, windowsHide: true });
+                            (options.location === 'user' ? ' --home' : ''), { env, windowsHide: false });
                         devkit_1.logger.info(`Cleared custom yarn ${registryConfigName}`);
                     }
                 });

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

@@ -121,7 +121,7 @@ To fix this you will either need to add a package.json file at that location, or
                             // 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: true,
+                                    windowsHide: false,
                                 }, (error, stdout, stderr) => {
                                     if (error) {
                                         return reject(error);

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

@@ -89,7 +89,7 @@ function execLockFileUpdate(command, cwd, env = {}) {
                 ...process.env,
                 ...env,
             },
-            windowsHide: true,
+            windowsHide: false,
         });
     }
     catch (e) {

package/src/generators/setup-verdaccio/generator.js

@@ -10,7 +10,7 @@ async function setupVerdaccio(tree, options) {
     if (!tree.exists('.verdaccio/config.yml')) {
         (0, devkit_1.generateFiles)(tree, path.join(__dirname, 'files'), '.verdaccio', {
             npmUplinkRegistry: (0, child_process_1.execSync)('npm config get registry', {
-                windowsHide: true,
+                windowsHide: false,
             })
                 ?.toString()
                 ?.trim() ?? 'https://registry.npmjs.org',

package/src/generators/typescript-sync/typescript-sync.js

@@ -30,28 +30,35 @@ async function syncGenerator(tree) {
             `The "${plugin_1.PLUGIN_NAME}" plugin must be added to the "plugins" array in "nx.json" in order to sync the project graph information to the TypeScript configuration files.`,
         ]);
     }
+    const tsconfigInfoCaches = {
+        composite: new Map(),
+        content: new Map(),
+        exists: new Map(),
+        isFile: new Map(),
+    };
     // Root tsconfig containing project references for the whole workspace
     const rootTsconfigPath = 'tsconfig.json';
-    if (!tree.exists(rootTsconfigPath)) {
+    if (!tsconfigExists(tree, tsconfigInfoCaches, rootTsconfigPath)) {
         throw new sync_generators_1.SyncError('Missing root "tsconfig.json"', [
             `A "tsconfig.json" file must exist in the workspace root in order to sync the project graph information to the TypeScript configuration files.`,
         ]);
     }
-    const rawTsconfigContentsCache = new Map();
-    const stringifiedRootJsonContents = readRawTsconfigContents(tree, rawTsconfigContentsCache, rootTsconfigPath);
+    const stringifiedRootJsonContents = readRawTsconfigContents(tree, tsconfigInfoCaches, rootTsconfigPath);
     const rootTsconfig = (0, devkit_1.parseJson)(stringifiedRootJsonContents);
     const projectGraph = await (0, devkit_1.createProjectGraphAsync)();
     const projectRoots = new Set();
-    const tsconfigHasCompositeEnabledCache = new Map();
     const tsconfigProjectNodeValues = Object.values(projectGraph.nodes).filter((node) => {
         projectRoots.add(node.data.root);
         const projectTsconfigPath = (0, devkit_1.joinPathFragments)(node.data.root, 'tsconfig.json');
-        return tsconfigExists(tree, rawTsconfigContentsCache, projectTsconfigPath);
+        return tsconfigExists(tree, tsconfigInfoCaches, projectTsconfigPath);
     });
     const tsSysFromTree = {
         ...ts.sys,
+        fileExists(path) {
+            return tsconfigExists(tree, tsconfigInfoCaches, path);
+        },
         readFile(path) {
-            return readRawTsconfigContents(tree, rawTsconfigContentsCache, path);
+            return readRawTsconfigContents(tree, tsconfigInfoCaches, path);
         },
     };
     // Track if any changes were made to the tsconfig files. We check the changes
@@ -63,8 +70,8 @@ async function syncGenerator(tree) {
         const referencesSet = new Set();
         for (const ref of rootTsconfig.references ?? []) {
             // reference path is relative to the tsconfig file
-            const resolvedRefPath = getTsConfigPathFromReferencePath(tree, rootTsconfigPath, ref.path);
-            if (tsconfigExists(tree, rawTsconfigContentsCache, resolvedRefPath)) {
+            const resolvedRefPath = getTsConfigPathFromReferencePath(tree, rootTsconfigPath, ref.path, tsconfigInfoCaches);
+            if (tsconfigExists(tree, tsconfigInfoCaches, resolvedRefPath)) {
                 // we only keep the references that still exist
                 referencesSet.add(normalizeReferencePath(ref.path));
             }
@@ -83,11 +90,11 @@ async function syncGenerator(tree) {
         if (hasChanges) {
             const updatedReferences = Array.from(referencesSet)
                 // Check composite is true in the internal reference before proceeding
-                .filter((ref) => hasCompositeEnabled(tsSysFromTree, tsconfigHasCompositeEnabledCache, (0, devkit_1.joinPathFragments)(ref, 'tsconfig.json')))
+                .filter((ref) => hasCompositeEnabled(tsSysFromTree, tsconfigInfoCaches, (0, devkit_1.joinPathFragments)(ref, 'tsconfig.json')))
                 .map((ref) => ({
                 path: `./${ref}`,
             }));
-            patchTsconfigJsonReferences(tree, rawTsconfigContentsCache, rootTsconfigPath, updatedReferences);
+            patchTsconfigJsonReferences(tree, tsconfigInfoCaches, rootTsconfigPath, updatedReferences);
         }
     }
     const userOptions = nxJson.sync?.generatorOptions?.['@nx/js:typescript-sync'];
@@ -105,7 +112,7 @@ async function syncGenerator(tree) {
         const sourceProjectNode = projectGraph.nodes[projectName];
         // Find the relevant tsconfig file for the source project
         const sourceProjectTsconfigPath = (0, devkit_1.joinPathFragments)(sourceProjectNode.data.root, 'tsconfig.json');
-        if (!tsconfigExists(tree, rawTsconfigContentsCache, sourceProjectTsconfigPath)) {
+        if (!tsconfigExists(tree, tsconfigInfoCaches, sourceProjectTsconfigPath)) {
             if (process.env.NX_VERBOSE_LOGGING === 'true') {
                 devkit_1.logger.warn(`Skipping project "${projectName}" as there is no tsconfig.json file found in the project root "${sourceProjectNode.data.root}".`);
             }
@@ -115,16 +122,16 @@ async function syncGenerator(tree) {
         const dependencies = collectProjectDependencies(tree, projectName, projectGraph, collectedDependencies);
         for (const runtimeTsConfigFileName of runtimeTsConfigFileNames) {
             const runtimeTsConfigPath = (0, devkit_1.joinPathFragments)(sourceProjectNode.data.root, runtimeTsConfigFileName);
-            if (!tsconfigExists(tree, rawTsconfigContentsCache, runtimeTsConfigPath)) {
+            if (!tsconfigExists(tree, tsconfigInfoCaches, runtimeTsConfigPath)) {
                 continue;
             }
             // Update project references for the runtime tsconfig
             hasChanges =
-                updateTsConfigReferences(tree, tsSysFromTree, rawTsconfigContentsCache, tsconfigHasCompositeEnabledCache, runtimeTsConfigPath, dependencies, sourceProjectNode.data.root, projectRoots, runtimeTsConfigFileName, runtimeTsConfigFileNames) || hasChanges;
+                updateTsConfigReferences(tree, tsSysFromTree, tsconfigInfoCaches, runtimeTsConfigPath, dependencies, sourceProjectNode.data.root, projectRoots, runtimeTsConfigFileName, runtimeTsConfigFileNames) || hasChanges;
         }
         // Update project references for the tsconfig.json file
         hasChanges =
-            updateTsConfigReferences(tree, tsSysFromTree, rawTsconfigContentsCache, tsconfigHasCompositeEnabledCache, sourceProjectTsconfigPath, dependencies, sourceProjectNode.data.root, projectRoots) || hasChanges;
+            updateTsConfigReferences(tree, tsSysFromTree, tsconfigInfoCaches, sourceProjectTsconfigPath, dependencies, sourceProjectNode.data.root, projectRoots) || hasChanges;
     }
     if (hasChanges) {
         await (0, devkit_1.formatFiles)(tree);
@@ -138,23 +145,24 @@ exports.default = syncGenerator;
  * Within the context of a sync generator, performance is a key concern,
  * so avoid FS interactions whenever possible.
  */
-function readRawTsconfigContents(tree, rawTsconfigContentsCache, tsconfigPath) {
-    if (!rawTsconfigContentsCache.has(tsconfigPath)) {
-        rawTsconfigContentsCache.set(tsconfigPath, tree.read(tsconfigPath, 'utf-8'));
+function readRawTsconfigContents(tree, tsconfigInfoCaches, tsconfigPath) {
+    if (!tsconfigInfoCaches.content.has(tsconfigPath)) {
+        tsconfigInfoCaches.content.set(tsconfigPath, tree.read(tsconfigPath, 'utf-8'));
     }
-    return rawTsconfigContentsCache.get(tsconfigPath);
+    return tsconfigInfoCaches.content.get(tsconfigPath);
 }
 /**
  * Within the context of a sync generator, performance is a key concern,
  * so avoid FS interactions whenever possible.
  */
-function tsconfigExists(tree, rawTsconfigContentsCache, tsconfigPath) {
-    return rawTsconfigContentsCache.has(tsconfigPath)
-        ? true
-        : tree.exists(tsconfigPath);
+function tsconfigExists(tree, tsconfigInfoCaches, tsconfigPath) {
+    if (!tsconfigInfoCaches.exists.has(tsconfigPath)) {
+        tsconfigInfoCaches.exists.set(tsconfigPath, tree.exists(tsconfigPath));
+    }
+    return tsconfigInfoCaches.exists.get(tsconfigPath);
 }
-function updateTsConfigReferences(tree, tsSysFromTree, rawTsconfigContentsCache, tsconfigHasCompositeEnabledCache, tsConfigPath, dependencies, projectRoot, projectRoots, runtimeTsConfigFileName, possibleRuntimeTsConfigFileNames) {
-    const stringifiedJsonContents = readRawTsconfigContents(tree, rawTsconfigContentsCache, tsConfigPath);
+function updateTsConfigReferences(tree, tsSysFromTree, tsconfigInfoCaches, tsConfigPath, dependencies, projectRoot, projectRoots, runtimeTsConfigFileName, possibleRuntimeTsConfigFileNames) {
+    const stringifiedJsonContents = readRawTsconfigContents(tree, tsconfigInfoCaches, tsConfigPath);
     const tsConfig = (0, devkit_1.parseJson)(stringifiedJsonContents);
     const ignoredReferences = new Set(tsConfig.nx?.sync?.ignoredReferences ?? []);
     // We have at least one dependency so we can safely set it to an empty array if not already set
@@ -171,8 +179,8 @@ function updateTsConfigReferences(tree, tsSysFromTree, rawTsconfigContentsCache,
             continue;
         }
         // reference path is relative to the tsconfig file
-        const resolvedRefPath = getTsConfigPathFromReferencePath(tree, tsConfigPath, ref.path);
-        if (isProjectReferenceWithinNxProject(tree, rawTsconfigContentsCache, resolvedRefPath, projectRoot, projectRoots) ||
+        const resolvedRefPath = getTsConfigPathFromReferencePath(tree, tsConfigPath, ref.path, tsconfigInfoCaches);
+        if (isProjectReferenceWithinNxProject(tree, tsconfigInfoCaches, resolvedRefPath, projectRoot, projectRoots) ||
             isProjectReferenceIgnored(tree, resolvedRefPath)) {
             // we keep all references within the current Nx project or that are ignored
             references.push(ref);
@@ -185,9 +193,9 @@ function updateTsConfigReferences(tree, tsSysFromTree, rawTsconfigContentsCache,
         let referencePath = dep.data.root;
         if (runtimeTsConfigFileName) {
             const runtimeTsConfigPath = (0, devkit_1.joinPathFragments)(dep.data.root, runtimeTsConfigFileName);
-            if (tsconfigExists(tree, rawTsconfigContentsCache, runtimeTsConfigPath)) {
+            if (tsconfigExists(tree, tsconfigInfoCaches, runtimeTsConfigPath)) {
                 // Check composite is true in the dependency runtime tsconfig file before proceeding
-                if (!hasCompositeEnabled(tsSysFromTree, tsconfigHasCompositeEnabledCache, runtimeTsConfigPath)) {
+                if (!hasCompositeEnabled(tsSysFromTree, tsconfigInfoCaches, runtimeTsConfigPath)) {
                     continue;
                 }
                 referencePath = runtimeTsConfigPath;
@@ -198,9 +206,9 @@ function updateTsConfigReferences(tree, tsSysFromTree, rawTsconfigContentsCache,
                 for (const possibleRuntimeTsConfigFileName of possibleRuntimeTsConfigFileNames ??
                     []) {
                     const possibleRuntimeTsConfigPath = (0, devkit_1.joinPathFragments)(dep.data.root, possibleRuntimeTsConfigFileName);
-                    if (tsconfigExists(tree, rawTsconfigContentsCache, possibleRuntimeTsConfigPath)) {
+                    if (tsconfigExists(tree, tsconfigInfoCaches, possibleRuntimeTsConfigPath)) {
                         // Check composite is true in the dependency runtime tsconfig file before proceeding
-                        if (!hasCompositeEnabled(tsSysFromTree, tsconfigHasCompositeEnabledCache, possibleRuntimeTsConfigPath)) {
+                        if (!hasCompositeEnabled(tsSysFromTree, tsconfigInfoCaches, possibleRuntimeTsConfigPath)) {
                             continue;
                         }
                         referencePath = possibleRuntimeTsConfigPath;
@@ -211,7 +219,7 @@ function updateTsConfigReferences(tree, tsSysFromTree, rawTsconfigContentsCache,
         }
         else {
             // Check composite is true in the dependency tsconfig.json file before proceeding
-            if (!hasCompositeEnabled(tsSysFromTree, tsconfigHasCompositeEnabledCache, (0, devkit_1.joinPathFragments)(dep.data.root, 'tsconfig.json'))) {
+            if (!hasCompositeEnabled(tsSysFromTree, tsconfigInfoCaches, (0, devkit_1.joinPathFragments)(dep.data.root, 'tsconfig.json'))) {
                 continue;
             }
         }
@@ -227,7 +235,7 @@ function updateTsConfigReferences(tree, tsSysFromTree, rawTsconfigContentsCache,
     }
     hasChanges ||= newReferencesSet.size !== originalReferencesSet.size;
     if (hasChanges) {
-        patchTsconfigJsonReferences(tree, rawTsconfigContentsCache, tsConfigPath, references);
+        patchTsconfigJsonReferences(tree, tsconfigInfoCaches, tsConfigPath, references);
     }
     return hasChanges;
 }
@@ -273,8 +281,8 @@ function normalizeReferencePath(path) {
         .replace(/\/tsconfig.json$/, '')
         .replace(/^\.\//, '');
 }
-function isProjectReferenceWithinNxProject(tree, rawTsconfigContentsCache, refTsConfigPath, projectRoot, projectRoots) {
-    let currentPath = getTsConfigDirName(tree, rawTsconfigContentsCache, refTsConfigPath);
+function isProjectReferenceWithinNxProject(tree, tsconfigInfoCaches, refTsConfigPath, projectRoot, projectRoots) {
+    let currentPath = getTsConfigDirName(tree, tsconfigInfoCaches, refTsConfigPath);
     if ((0, posix_1.relative)(projectRoot, currentPath).startsWith('..')) {
         // it's outside of the project root, so it's an external project reference
         return false;
@@ -300,16 +308,14 @@ function isProjectReferenceIgnored(tree, refTsConfigPath) {
     }
     return ig.ignores(refTsConfigPath);
 }
-function getTsConfigDirName(tree, rawTsconfigContentsCache, tsConfigPath) {
-    return (rawTsconfigContentsCache.has(tsConfigPath)
-        ? true
-        : tree.isFile(tsConfigPath))
+function getTsConfigDirName(tree, tsconfigInfoCaches, tsConfigPath) {
+    return tsconfigIsFile(tree, tsconfigInfoCaches, tsConfigPath)
         ? (0, posix_1.dirname)(tsConfigPath)
         : (0, posix_1.normalize)(tsConfigPath);
 }
-function getTsConfigPathFromReferencePath(tree, ownerTsConfigPath, referencePath) {
+function getTsConfigPathFromReferencePath(tree, ownerTsConfigPath, referencePath, tsconfigInfoCaches) {
     const resolvedRefPath = (0, devkit_1.joinPathFragments)((0, posix_1.dirname)(ownerTsConfigPath), referencePath);
-    return tree.isFile(resolvedRefPath)
+    return tsconfigIsFile(tree, tsconfigInfoCaches, resolvedRefPath)
         ? resolvedRefPath
         : (0, devkit_1.joinPathFragments)(resolvedRefPath, 'tsconfig.json');
 }
@@ -317,18 +323,29 @@ function getTsConfigPathFromReferencePath(tree, ownerTsConfigPath, referencePath
  * Minimally patch just the "references" property within the tsconfig file at a given path.
  * This allows comments in other sections of the file to remain intact when syncing is run.
  */
-function patchTsconfigJsonReferences(tree, rawTsconfigContentsCache, tsconfigPath, updatedReferences) {
-    const stringifiedJsonContents = readRawTsconfigContents(tree, rawTsconfigContentsCache, tsconfigPath);
+function patchTsconfigJsonReferences(tree, tsconfigInfoCaches, tsconfigPath, updatedReferences) {
+    const stringifiedJsonContents = readRawTsconfigContents(tree, tsconfigInfoCaches, tsconfigPath);
     const edits = (0, jsonc_parser_1.modify)(stringifiedJsonContents, ['references'], updatedReferences, {});
     const updatedJsonContents = (0, jsonc_parser_1.applyEdits)(stringifiedJsonContents, edits);
     // The final contents will be formatted by formatFiles() later
     tree.write(tsconfigPath, updatedJsonContents);
 }
-function hasCompositeEnabled(tsSysFromTree, tsconfigHasCompositeEnabledCache, tsconfigPath) {
-    if (!tsconfigHasCompositeEnabledCache.has(tsconfigPath)) {
+function hasCompositeEnabled(tsSysFromTree, tsconfigInfoCaches, tsconfigPath) {
+    if (!tsconfigInfoCaches.composite.has(tsconfigPath)) {
         const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(tsconfigPath, tsSysFromTree.readFile).config, tsSysFromTree, (0, posix_1.dirname)(tsconfigPath));
-        const enabledVal = parsed.options.composite === true;
-        tsconfigHasCompositeEnabledCache.set(tsconfigPath, enabledVal);
+        tsconfigInfoCaches.composite.set(tsconfigPath, parsed.options.composite === true);
+    }
+    return tsconfigInfoCaches.composite.get(tsconfigPath);
+}
+function tsconfigIsFile(tree, tsconfigInfoCaches, tsconfigPath) {
+    if (tsconfigInfoCaches.isFile.has(tsconfigPath)) {
+        return tsconfigInfoCaches.isFile.get(tsconfigPath);
+    }
+    if (tsconfigInfoCaches.content.has(tsconfigPath)) {
+        // if it has content, it's a file
+        tsconfigInfoCaches.isFile.set(tsconfigPath, true);
+        return true;
     }
-    return tsconfigHasCompositeEnabledCache.get(tsconfigPath);
+    tsconfigInfoCaches.isFile.set(tsconfigPath, tree.isFile(tsconfigPath));
+    return tsconfigInfoCaches.isFile.get(tsconfigPath);
 }

package/src/plugins/jest/start-local-registry.js

@@ -28,7 +28,7 @@ function startLocalRegistry({ localRegistryTarget, storage, verbose, clearStorag
                 const registry = `http://localhost:${port}`;
                 process.env.npm_config_registry = registry;
                 (0, child_process_1.execSync)(`npm config set //localhost:${port}/:_authToken "secretVerdaccioToken"`, {
-                    windowsHide: true,
+                    windowsHide: false,
                 });
                 // yarnv1
                 process.env.YARN_REGISTRY = registry;
@@ -39,7 +39,7 @@ function startLocalRegistry({ localRegistryTarget, storage, verbose, clearStorag
                 resolve(() => {
                     childProcess.kill();
                     (0, child_process_1.execSync)(`npm config delete //localhost:${port}/:_authToken`, {
-                        windowsHide: true,
+                        windowsHide: false,
                     });
                 });
                 childProcess?.stdout?.off('data', listener);

package/src/plugins/typescript/plugin.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodes = exports.createNodesV2 = exports.PLUGIN_NAME = exports.createDependencies = void 0;
 const devkit_1 = require("@nx/devkit");
-const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
 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");
@@ -37,8 +36,9 @@ exports.createNodesV2 = [
         const cachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `tsc-${optionsHash}.hash`);
         const targetsCache = readTargetsCache(cachePath);
         const normalizedOptions = normalizePluginOptions(options);
+        const lockFileName = (0, lock_file_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
         try {
-            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => createNodesInternal(configFile, options, context, targetsCache), configFilePaths, normalizedOptions, context);
+            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => createNodesInternal(configFile, options, context, lockFileName, targetsCache), configFilePaths, normalizedOptions, context);
         }
         finally {
             writeTargetsToCache(cachePath, targetsCache);
@@ -50,10 +50,11 @@ exports.createNodes = [
     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 normalizedOptions = normalizePluginOptions(options);
-        return createNodesInternal(configFilePath, normalizedOptions, context, {});
+        const lockFileName = (0, lock_file_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
+        return createNodesInternal(configFilePath, normalizedOptions, context, lockFileName, {});
     },
 ];
-async function createNodesInternal(configFilePath, options, context, targetsCache) {
+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);
     // Do not create a project for the workspace root tsconfig files.
@@ -71,8 +72,20 @@ async function createNodesInternal(configFilePath, options, context, targetsCach
         !siblingFiles.includes('tsconfig.json')) {
         return {};
     }
-    const nodeHash = await (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, context, [(0, lock_file_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot))]);
-    // The hash is calculated at the node/project level, so we add the config file path to avoid conflicts when caching
+    /**
+     * 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)
+     *   - lock file
+     * - hash of the plugin options
+     * - current config file path
+     */
+    const extendedConfigFiles = getExtendedConfigFiles(fullConfigPath, readCachedTsConfig(fullConfigPath));
+    const nodeHash = (0, file_hasher_1.hashArray)([
+        ...[configFilePath, ...extendedConfigFiles, lockFileName].map(file_hasher_1.hashFile),
+        (0, file_hasher_1.hashObject)(options),
+    ]);
     const cacheKey = `${nodeHash}_${configFilePath}`;
     targetsCache[cacheKey] ??= buildTscTargets(fullConfigPath, projectRoot, options, context);
     const { targets } = targetsCache[cacheKey];

package/src/utils/npm-config.js

@@ -76,7 +76,7 @@ async function getNpmConfigValue(key, cwd) {
 async function execAsync(command, cwd) {
     // Must be non-blocking async to allow spinner to render
     return new Promise((resolve, reject) => {
-        (0, child_process_1.exec)(command, { cwd, windowsHide: true }, (error, stdout, stderr) => {
+        (0, child_process_1.exec)(command, { cwd, windowsHide: false }, (error, stdout, stderr) => {
             if (error) {
                 return reject(error);
             }

package/src/utils/swc/compile-swc.js

@@ -62,7 +62,7 @@ async function compileSwc(context, normalizedOptions, postCompilationCallback) {
     const swcCmdLog = (0, node_child_process_1.execSync)(getSwcCmd(normalizedOptions), {
         encoding: 'utf8',
         cwd: normalizedOptions.swcCliOptions.swcCwd,
-        windowsHide: true,
+        windowsHide: false,
     });
     devkit_1.logger.log(swcCmdLog.replace(/\n/, ''));
     const isCompileSuccess = swcCmdLog.includes('Successfully compiled');
@@ -99,7 +99,7 @@ async function* compileSwcWatch(context, normalizedOptions, postCompilationCallb
         let watcherOnExit;
         const swcWatcher = (0, node_child_process_1.exec)(getSwcCmd(normalizedOptions, true), {
             cwd: normalizedOptions.swcCliOptions.swcCwd,
-            windowsHide: true,
+            windowsHide: false,
         });
         processOnExit = () => {
             swcWatcher.kill();