@nx/js 20.5.0-beta.3 → 20.5.0-beta.4

package/migrations.json

@@ -137,6 +137,15 @@
           "alwaysAddToPackageJson": false
         }
       }
+    },
+    "20.5.0": {
+      "version": "20.5.0-beta.3",
+      "packages": {
+        "verdaccio": {
+          "version": "^6.0.5",
+          "alwaysAddToPackageJson": false
+        }
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "20.5.0-beta.3",
+  "version": "20.5.0-beta.4",
   "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.5.0-beta.3",
-    "@nx/workspace": "20.5.0-beta.3",
+    "@nx/devkit": "20.5.0-beta.4",
+    "@nx/workspace": "20.5.0-beta.4",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^3.1.0",
@@ -64,7 +64,7 @@
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
-    "verdaccio": "^5.0.4"
+    "verdaccio": "^6.0.5"
   },
   "peerDependenciesMeta": {
     "verdaccio": {

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

@@ -34,19 +34,37 @@ async function runExecutor(options, context) {
     const packageJson = (0, devkit_1.readJsonFile)(packageJsonPath);
     const packageName = packageJson.name;
     /**
-     * pnpm supports dynamically updating locally linked packages during its packing phase, but other package managers do not.
-     * Therefore, protect the user from publishing invalid packages by checking if it contains local dependency protocols.
+     * Whether or not dynamically replacing local dependency protocols (such as "workspace:*") is supported during `nx release publish` is
+     * dependent on the package manager the user is using.
+     *
+     * npm does not support the workspace protocol at all, and `npm publish` does not support dynamically updating locally linked packages
+     * during its packing phase, so we give the user a clear error message informing them of that.
+     *
+     * - `pnpm publish` provides ideal support, it has the possibility of providing JSON output consistent with npm
+     * - `bun publish`, provides very good support, including all the flags we need apart from the JSON output, so we just have to accept that
+     * it will look and feel different and print what it gives us and perform one bit of string manipulation for the dry-run case.
+     * - `yarn npm publish`, IS NOT YET SUPPORTED, and will be tricky because it does not support the majority of the flags we need. However, it
+     * does support replacing local dependency protocols with the correct version during its packing phase.
      */
-    if (pm !== 'pnpm') {
+    if (pm === 'npm' || pm === 'yarn') {
         const depTypes = ['dependencies', 'devDependencies', 'peerDependencies'];
         for (const depType of depTypes) {
             const deps = packageJson[depType];
             if (deps) {
                 for (const depName in deps) {
                     if ((0, is_locally_linked_package_version_1.isLocallyLinkedPackageVersion)(deps[depName])) {
-                        console.error(`Error: Cannot publish package "${packageName}" because it contains a local dependency protocol in its "${depType}", and your package manager is ${pm}.
+                        if (pm === 'npm') {
+                            console.error(`Error: Cannot publish package "${packageName}" because it contains a local dependency protocol in its "${depType}", and your package manager is npm.
+
+Please update the local dependency on "${depName}" to be a valid semantic version (e.g. using \`nx release\`) before publishing, or switch to pnpm or bun as a package manager, which support dynamically replacing these protocols during publishing.`);
+                        }
+                        else if (pm === 'yarn') {
+                            console.error(`Error: Cannot publish package "${packageName}" because it contains a local dependency protocol in its "${depType}", and your package manager is yarn.
+
+Currently, yarn is not supported for this use case because its \`yarn npm publish\` command does not support the customization needed.
 
-Please update the local dependency on "${depName}" to be a valid semantic version (e.g. using \`nx release\`) before publishing, or switch to pnpm as a package manager, which supports dynamically replacing these protocols during publishing.`);
+Please update the local dependency on "${depName}" to be a valid semantic version (e.g. using \`nx release\`) before publishing, or switch to pnpm or bun as a package manager, which support dynamically replacing these protocols during publishing.`);
+                        }
                         return {
                             success: false,
                         };
@@ -184,10 +202,13 @@ Please update the local dependency on "${depName}" to be a valid semantic versio
      * JSON output under the name of the package in that case (and it would need to be handled below).
      */
     const publishCommandSegments = [
-        pm === 'pnpm'
-            ? // Unlike npm, pnpm publish does not support a custom registryConfigKey option, and will error on uncommitted changes by default if --no-git-checks is not set
-                `pnpm publish "${packageRoot}" --json --registry="${registry}" --tag=${tag} --no-git-checks`
-            : `npm publish "${packageRoot}" --json --"${registryConfigKey}=${registry}" --tag=${tag}`,
+        pm === 'bun'
+            ? // Unlike npm, bun publish does not support a custom registryConfigKey option
+                `bun publish --cwd="${packageRoot}" --json --registry="${registry}" --tag=${tag}`
+            : pm === 'pnpm'
+                ? // Unlike npm, pnpm publish does not support a custom registryConfigKey option, and will error on uncommitted changes by default if --no-git-checks is not set
+                    `pnpm publish "${packageRoot}" --json --registry="${registry}" --tag=${tag} --no-git-checks`
+                : `npm publish "${packageRoot}" --json --"${registryConfigKey}=${registry}" --tag=${tag}`,
     ];
     if (options.otp) {
         publishCommandSegments.push(`--otp=${options.otp}`);
@@ -206,6 +227,23 @@ Please update the local dependency on "${depName}" to be a valid semantic versio
             stdio: ['ignore', 'pipe', 'pipe'],
             windowsHide: false,
         });
+        // If in dry-run mode, the version on disk will not represent the version that would be published, so we scrub it from the output to avoid confusion.
+        const dryRunVersionPlaceholder = 'X.X.X-dry-run';
+        const publishSummaryMessage = isDryRun
+            ? `Would publish to ${registry} with tag "${tag}", but ${chalk.keyword('orange')('[dry-run]')} was set`
+            : `Published to ${registry} with tag "${tag}"`;
+        // bun publish does not support outputting JSON, so we need to modify and print the output string directly
+        if (pm === 'bun') {
+            let outputStr = output.toString();
+            if (isDryRun) {
+                outputStr = outputStr.replace(new RegExp(`${packageJson.name}@${packageJson.version}`, 'g'), `${packageJson.name}@${dryRunVersionPlaceholder}`);
+            }
+            console.log(outputStr);
+            console.log(publishSummaryMessage);
+            return {
+                success: true,
+            };
+        }
         /**
          * 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.
          * Additionally, we want to capture and show the lifecycle script outputs as beforeJsonData and afterJsonData and print them accordingly below.
@@ -217,8 +255,6 @@ Please update the local dependency on "${depName}" to be a valid semantic versio
                 success: false,
             };
         }
-        // If in dry-run mode, the version on disk will not represent the version that would be published, so we scrub it from the output to avoid confusion.
-        const dryRunVersionPlaceholder = 'X.X.X-dry-run';
         if (isDryRun) {
             for (const [key, val] of Object.entries(jsonData)) {
                 if (typeof val !== 'string') {
@@ -235,18 +271,23 @@ Please update the local dependency on "${depName}" to be a valid semantic versio
         if (typeof afterJsonData === 'string' && afterJsonData.trim().length > 0) {
             console.log(afterJsonData);
         }
-        if (isDryRun) {
-            console.log(`Would publish to ${registry} with tag "${tag}", but ${chalk.keyword('orange')('[dry-run]')} was set`);
-        }
-        else {
-            console.log(`Published to ${registry} with tag "${tag}"`);
-        }
+        // Print the summary message after the JSON data has been printed
+        console.log(publishSummaryMessage);
         return {
             success: true,
         };
     }
     catch (err) {
         try {
+            // bun publish does not support outputting JSON, so we cannot perform any further processing
+            if (pm === 'bun') {
+                console.error(`bun publish error:`);
+                console.error(err.stderr?.toString() || '');
+                console.error(err.stdout?.toString() || '');
+                return {
+                    success: false,
+                };
+            }
             const stdoutData = JSON.parse(err.stdout?.toString() || '{}');
             console.error(`${pm} publish error:`);
             if (stdoutData.error?.summary) {

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 &&
@@ -404,7 +404,7 @@ To fix this you will either need to add a package.json file at that location, or
             const allDependentProjects = Object.values(localPackageDependencies)
                 .flat()
                 .filter((localPackageDependency) => {
-                return localPackageDependency.target === project.name;
+                return localPackageDependency.target === projectName;
             });
             const includeTransitiveDependents = updateDependents !== 'never' &&
                 options.releaseGroup.projectsRelationship === 'independent';
@@ -423,9 +423,10 @@ To fix this you will either need to add a package.json file at that location, or
             const dependentProjectsOutsideCurrentBatch = [];
             // Track circular dependencies using value of project1:project2
             const circularDependencies = new Set();
+            const projectsDependOnCurrentProject = localPackageDependencies[projectName]?.map((localPackageDependencies) => localPackageDependencies.target) ?? [];
             for (const dependentProject of allDependentProjects) {
                 // Track circular dependencies (add both directions for easy look up)
-                if (dependentProject.target === projectName) {
+                if (projectsDependOnCurrentProject.includes(dependentProject.source)) {
                     circularDependencies.add(`${dependentProject.source}:${dependentProject.target}`);
                     circularDependencies.add(`${dependentProject.target}:${dependentProject.source}`);
                 }

package/src/plugins/typescript/plugin.js

@@ -15,6 +15,7 @@ const util_1 = require("./util");
 const pmc = (0, devkit_1.getPackageManagerCommand)();
 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'
@@ -43,11 +44,10 @@ exports.createNodesV2 = [
         const optionsHash = (0, file_hasher_1.hashObject)(options);
         const targetsCachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `tsc-${optionsHash}.hash`);
         const targetsCache = readFromCache(targetsCachePath);
-        tsConfigCache =
-            readFromCache(tsConfigCachePath);
+        cache = { fileHashes: {}, rawFiles: {}, isExternalProjectReference: {} };
+        initializeTsConfigCache(configFilePaths, context.workspaceRoot);
         const normalizedOptions = normalizePluginOptions(options);
-        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 { configFilePaths: validConfigFilePaths, hashes, projectRoots, } = await resolveValidConfigFilesAndHashes(configFilePaths, optionsHash, lockFileHash, context);
+        const { configFilePaths: validConfigFilePaths, hashes, projectRoots, } = await resolveValidConfigFilesAndHashes(configFilePaths, optionsHash, context);
         try {
             return await (0, devkit_1.createNodesFromFiles)((configFilePath, options, context, idx) => {
                 const projectRoot = projectRoots[idx];
@@ -67,7 +67,7 @@ exports.createNodesV2 = [
         }
         finally {
             writeToCache(targetsCachePath, targetsCache);
-            writeToCache(tsConfigCachePath, tsConfigCache);
+            writeToCache(tsConfigCachePath, toRelativePaths(tsConfigCache, context.workspaceRoot));
         }
     },
 ];
@@ -80,9 +80,10 @@ exports.createNodes = [
             return {};
         }
         const normalizedOptions = normalizePluginOptions(options);
-        tsConfigCache =
-            readFromCache(tsConfigCachePath);
+        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]: {
@@ -93,11 +94,11 @@ exports.createNodes = [
         };
     },
 ];
-async function resolveValidConfigFilesAndHashes(configFilePaths, optionsHash, lockFileHash, context) {
+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 = [];
-    const fileHashesCache = {};
     for await (const configFilePath of configFilePaths) {
         const projectRoot = (0, node_path_1.dirname)(configFilePath);
         if (!checkIfConfigFileShouldBeProject(configFilePath, projectRoot, context)) {
@@ -105,7 +106,7 @@ async function resolveValidConfigFilesAndHashes(configFilePaths, optionsHash, lo
         }
         projectRoots.push(projectRoot);
         validConfigFilePaths.push(configFilePath);
-        hashes.push(await getConfigFileHash(configFilePath, context.workspaceRoot, projectRoot, optionsHash, lockFileHash, fileHashesCache));
+        hashes.push(await getConfigFileHash(configFilePath, context.workspaceRoot, projectRoot, optionsHash, lockFileHash));
     }
     return { configFilePaths: validConfigFilePaths, hashes, projectRoots };
 }
@@ -121,10 +122,10 @@ async function resolveValidConfigFilesAndHashes(configFilePaths, optionsHash, lo
  * - hash of the plugin options
  * - current config file path
  */
-async function getConfigFileHash(configFilePath, workspaceRoot, projectRoot, optionsHash, lockFileHash, fileHashesCache) {
+async function getConfigFileHash(configFilePath, workspaceRoot, projectRoot, optionsHash, lockFileHash) {
     const fullConfigPath = (0, node_path_1.join)(workspaceRoot, configFilePath);
-    const tsConfig = readCachedTsConfig(fullConfigPath, workspaceRoot);
-    const extendedConfigFiles = getExtendedConfigFiles(fullConfigPath, tsConfig, workspaceRoot);
+    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;
@@ -135,13 +136,11 @@ async function getConfigFileHash(configFilePath, workspaceRoot, projectRoot, opt
     return (0, file_hasher_1.hashArray)([
         ...[
             fullConfigPath,
-            ...extendedConfigFiles.files,
-            ...Object.keys(internalReferencedFiles),
-            ...Object.keys(externalProjectReferences),
-        ].map((file) => {
-            fileHashesCache[file] ??= (0, file_hasher_1.hashFile)(file);
-            return fileHashesCache[file];
-        }),
+            ...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)] : []),
@@ -176,7 +175,7 @@ function checkIfConfigFileShouldBeProject(configFilePath, projectRoot, context)
 function buildTscTargets(configFilePath, projectRoot, options, context) {
     const targets = {};
     const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
-    const tsConfig = readCachedTsConfig(configFilePath, context.workspaceRoot);
+    const tsConfig = retrieveTsConfigFromCache(configFilePath, context.workspaceRoot);
     let internalProjectReferences;
     // Typecheck target
     if ((0, node_path_1.basename)(configFilePath) === 'tsconfig.json' && options.typecheck) {
@@ -247,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, workspaceRoot);
+    const extendedConfigFiles = getExtendedConfigFiles(tsConfig, workspaceRoot);
     extendedConfigFiles.files.forEach((configPath) => {
         configFiles.add(configPath);
     });
@@ -460,23 +459,17 @@ function pathToInputOrOutput(path, workspaceRoot, projectRoot) {
     }
     return (0, devkit_1.joinPathFragments)('{projectRoot}', pathRelativeToProjectRoot);
 }
-function getExtendedConfigFiles(tsConfigPath, tsConfig, workspaceRoot) {
+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) {
+    let currentExtendedConfigFile = tsConfig.extendedConfigFile;
+    while (currentExtendedConfigFile) {
+        if (currentExtendedConfigFile.externalPackage) {
+            extendedExternalPackages.add(currentExtendedConfigFile.externalPackage);
             break;
         }
-        if (extendedConfigPath.externalPackage) {
-            extendedExternalPackages.add(extendedConfigPath.externalPackage);
-            break;
-        }
-        extendedConfigFiles.add(extendedConfigPath.filePath);
-        currentConfig = readCachedTsConfig(extendedConfigPath.filePath, workspaceRoot);
-        currentConfigPath = extendedConfigPath.filePath;
+        extendedConfigFiles.add(currentExtendedConfigFile.filePath);
+        currentExtendedConfigFile = retrieveTsConfigFromCache(currentExtendedConfigFile.filePath, workspaceRoot).extendedConfigFile;
     }
     return {
         files: Array.from(extendedConfigFiles),
@@ -503,7 +496,7 @@ function resolveInternalProjectReferences(tsConfig, workspaceRoot, projectRoot,
         if (!refConfigPath.endsWith('.json')) {
             refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
         }
-        projectReferences[refConfigPath] = readCachedTsConfig(refConfigPath, workspaceRoot);
+        projectReferences[refConfigPath] = retrieveTsConfigFromCache(refConfigPath, workspaceRoot);
         resolveInternalProjectReferences(projectReferences[refConfigPath], workspaceRoot, projectRoot, projectReferences);
     }
     return projectReferences;
@@ -526,7 +519,7 @@ function resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, projec
             if (!refConfigPath.endsWith('.json')) {
                 refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
             }
-            projectReferences[refConfigPath] = readCachedTsConfig(refConfigPath, workspaceRoot);
+            projectReferences[refConfigPath] = retrieveTsConfigFromCache(refConfigPath, workspaceRoot);
         }
     }
     return projectReferences;
@@ -552,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, workspaceRoot);
+        const refTsConfig = retrieveTsConfigFromCache(refConfigPath, workspaceRoot);
         const result = hasExternalProjectReferences(refConfigPath, refTsConfig, workspaceRoot, projectRoot, seen);
         if (result) {
             return true;
@@ -561,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) {
@@ -583,32 +583,79 @@ function getTsConfigDirName(tsConfigPath) {
         ? (0, node_path_1.dirname)(tsConfigPath)
         : (0, node_path_1.normalize)(tsConfigPath);
 }
-function readCachedTsConfig(tsConfigPath, workspaceRoot) {
-    const relativeTsConfigPath = posix.relative(workspaceRoot, tsConfigPath);
-    const timestamp = (0, node_fs_1.statSync)(tsConfigPath).mtimeMs;
-    if (tsConfigCache[relativeTsConfigPath]?.timestamp === timestamp) {
-        return tsConfigCache[relativeTsConfigPath].data;
-    }
-    const tsConfig = readTsConfig(tsConfigPath);
-    tsConfigCache[relativeTsConfigPath] = {
+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,
         },
-        timestamp,
+        hash,
+        extendedFilesHash,
     };
-    return tsConfig;
+    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('|');
 }
 let ts;
-function readTsConfig(tsConfigPath) {
+function readTsConfig(tsConfigPath, workspaceRoot) {
     if (!ts) {
         ts = require('typescript');
     }
-    const readResult = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
+    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, { ...ts.sys, readDirectory: () => [] }, (0, node_path_1.dirname)(tsConfigPath));
+    return ts.parseJsonConfigFileContent(readResult.config, tsSys, (0, node_path_1.dirname)(tsConfigPath));
 }
 function normalizePluginOptions(pluginOptions = {}) {
     const defaultTypecheckTargetName = 'typecheck';
@@ -668,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/buildable-libs-utils.js

@@ -16,6 +16,7 @@ const fileutils_1 = require("nx/src/utils/fileutils");
 const output_1 = require("nx/src/utils/output");
 const path_1 = require("path");
 const ts_config_1 = require("./typescript/ts-config");
+const crypto_1 = require("crypto");
 function isBuildable(target, node) {
     return (node.data.targets &&
         node.data.targets[target] &&
@@ -229,7 +230,7 @@ function computeCompilerOptionsPaths(tsConfig, dependencies) {
     return paths;
 }
 function createTmpTsConfig(tsconfigPath, workspaceRoot, projectRoot, dependencies, useWorkspaceAsBaseUrl = false) {
-    const tmpTsConfigPath = (0, path_1.join)(workspaceRoot, 'tmp', projectRoot, process.env.NX_TASK_TARGET_TARGET ?? 'build', 'tsconfig.generated.json');
+    const tmpTsConfigPath = (0, path_1.join)(workspaceRoot, 'tmp', projectRoot, process.env.NX_TASK_TARGET_TARGET ?? 'build', `tsconfig.generated.${(0, crypto_1.randomUUID)()}.json`);
     if (tsconfigPath === tmpTsConfigPath) {
         return tsconfigPath;
     }

package/src/utils/versions.d.ts

@@ -7,7 +7,7 @@ export declare const swcHelpersVersion = "~0.5.11";
 export declare const swcNodeVersion = "~1.9.1";
 export declare const tsLibVersion = "^2.3.0";
 export declare const typesNodeVersion = "18.16.9";
-export declare const verdaccioVersion = "^5.0.4";
+export declare const verdaccioVersion = "^6.0.5";
 export declare const typescriptVersion = "~5.7.2";
 /**
  * The minimum version is currently determined from the lowest version

package/src/utils/versions.js

@@ -10,7 +10,7 @@ exports.swcHelpersVersion = '~0.5.11';
 exports.swcNodeVersion = '~1.9.1';
 exports.tsLibVersion = '^2.3.0';
 exports.typesNodeVersion = '18.16.9';
-exports.verdaccioVersion = '^5.0.4';
+exports.verdaccioVersion = '^6.0.5';
 // Typescript
 exports.typescriptVersion = '~5.7.2';
 /**