@nx/js 22.6.0-beta.10 → 22.6.0-beta.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "22.6.0-beta.10",
+  "version": "22.6.0-beta.12",
   "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": "22.6.0-beta.10",
-    "@nx/workspace": "22.6.0-beta.10",
+    "@nx/devkit": "22.6.0-beta.12",
+    "@nx/workspace": "22.6.0-beta.12",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^3.1.0",
@@ -60,7 +60,7 @@
     "tslib": "^2.3.0"
   },
   "devDependencies": {
-    "nx": "22.6.0-beta.10"
+    "nx": "22.6.0-beta.12"
   },
   "peerDependencies": {
     "verdaccio": "^6.0.5"

package/src/plugins/typescript/plugin.js

@@ -456,28 +456,42 @@ function getInputs(namedInputs, config, tsConfig, internalProjectReferences, wor
     if (excludePaths.size) {
         inputs.push(...Array.from(excludePaths).map((p) => `!${pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.project.root, p), workspaceRoot, config.project)}`));
     }
-    if (hasExternalProjectReferences(config.originalPath, tsConfig, workspaceRoot, config.project, cache)) {
-        // Importing modules from a referenced project will load its output declaration files (d.ts)
-        // https://www.typescriptlang.org/docs/handbook/project-references.html#what-is-a-project-reference
-        inputs.push({ dependentTasksOutputFiles: '**/*.d.ts' });
-    }
-    else {
-        inputs.push('production' in namedInputs ? '^production' : '^default');
+    // tsc --build reads .d.ts and .tsbuildinfo files from dependent tasks, not
+    // the source files of dependencies. This correctly tracks build outputs from
+    // both external project references and same-project task dependencies (e.g.
+    // build-native producing .d.ts files that may be excluded from file watching
+    // via .nxignore).
+    inputs.push({
+        dependentTasksOutputFiles: '**/*.{d.ts,tsbuildinfo}',
+        transitive: true,
+    });
+    const externalRefConfigFiles = getExternalProjectReferenceConfigFiles(tsConfig, internalProjectReferences, workspaceRoot, config.project, cache, configFiles);
+    if (externalRefConfigFiles.length > 0) {
+        // tsc --build also reads the tsconfig files from external project
+        // references (and their extended configs) when processing project
+        // references, so we need to add them as inputs
+        inputs.push(...externalRefConfigFiles.map((p) => pathToInputOrOutput(p, workspaceRoot, config.project)));
     }
     // inputs.push({ externalDependencies });
     return inputs;
 }
-function getOutputs(config, tsConfig, internalProjectReferences, workspaceRoot, emitDeclarationOnly) {
+function getOutputs(config, rootTsConfig, internalProjectReferences, workspaceRoot, emitDeclarationOnly) {
     const outputs = new Set();
     // We could have more surgical outputs based on the tsconfig options, but the
     // user could override them through the command line and that wouldn't be
     // reflected in the outputs. So, we just include everything that could be
     // produced by the tsc command.
-    [tsConfig, ...Object.values(internalProjectReferences)].forEach((tsconfig) => {
-        if (tsconfig.options.outFile) {
-            const outFileName = (0, node_path_1.basename)(tsconfig.options.outFile, '.js');
-            const outFileDir = (0, node_path_1.dirname)(tsconfig.options.outFile);
-            outputs.add(pathToInputOrOutput(tsconfig.options.outFile, workspaceRoot, config.project));
+    [
+        { configBaseNameNoExt: config.basenameNoExt, tsConfig: rootTsConfig },
+        ...Object.entries(internalProjectReferences).map(([internalConfigPath, internalConfig]) => ({
+            configBaseNameNoExt: (0, node_path_1.basename)(internalConfigPath, '.json'),
+            tsConfig: internalConfig,
+        })),
+    ].forEach(({ configBaseNameNoExt, tsConfig }) => {
+        if (tsConfig.options.outFile) {
+            const outFileName = (0, node_path_1.basename)(tsConfig.options.outFile, '.js');
+            const outFileDir = (0, node_path_1.dirname)(tsConfig.options.outFile);
+            outputs.add(pathToInputOrOutput(tsConfig.options.outFile, workspaceRoot, config.project));
             // outFile is not be used with .cjs, .mjs, .jsx, so the list is simpler
             const outDir = (0, node_path_1.relative)(workspaceRoot, outFileDir);
             outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.js.map`), workspaceRoot, config.project));
@@ -488,38 +502,36 @@ function getOutputs(config, tsConfig, internalProjectReferences, workspaceRoot,
                 ? pathToInputOrOutput(tsConfig.options.tsBuildInfoFile, workspaceRoot, config.project)
                 : pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.tsbuildinfo`), workspaceRoot, config.project));
         }
-        else if (tsconfig.options.outDir) {
+        else if (tsConfig.options.outDir) {
             if (emitDeclarationOnly) {
-                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(tsconfig.options.outDir, '**/*.d.ts'), workspaceRoot, config.project));
+                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(tsConfig.options.outDir, '**/*.d.ts'), workspaceRoot, config.project));
                 if (tsConfig.options.declarationMap) {
-                    outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(tsconfig.options.outDir, '**/*.d.ts.map'), workspaceRoot, config.project));
+                    outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(tsConfig.options.outDir, '**/*.d.ts.map'), workspaceRoot, config.project));
                 }
             }
             else {
-                outputs.add(pathToInputOrOutput(tsconfig.options.outDir, workspaceRoot, config.project));
+                outputs.add(pathToInputOrOutput(tsConfig.options.outDir, workspaceRoot, config.project));
             }
-            if (tsconfig.options.tsBuildInfoFile) {
+            if (tsConfig.options.tsBuildInfoFile) {
                 if (emitDeclarationOnly ||
-                    !(0, node_path_1.normalize)(tsconfig.options.tsBuildInfoFile).startsWith(`${(0, node_path_1.normalize)(tsconfig.options.outDir)}${node_path_1.sep}`)) {
+                    !(0, node_path_1.normalize)(tsConfig.options.tsBuildInfoFile).startsWith(`${(0, node_path_1.normalize)(tsConfig.options.outDir)}${node_path_1.sep}`)) {
                     // https://www.typescriptlang.org/tsconfig#tsBuildInfoFile
-                    outputs.add(pathToInputOrOutput(tsconfig.options.tsBuildInfoFile, workspaceRoot, config.project));
+                    outputs.add(pathToInputOrOutput(tsConfig.options.tsBuildInfoFile, workspaceRoot, config.project));
                 }
             }
-            else if (tsconfig.options.rootDir &&
-                tsconfig.options.rootDir !== '.') {
+            else if (tsConfig.options.rootDir && tsConfig.options.rootDir !== '.') {
                 // If rootDir is set, then the tsbuildinfo file will be outside the outDir so we need to add it.
-                const relativeRootDir = (0, node_path_1.relative)(tsconfig.options.rootDir, (0, node_path_1.join)(workspaceRoot, config.project.root));
-                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(tsconfig.options.outDir, relativeRootDir, `*.tsbuildinfo`), workspaceRoot, config.project));
+                const relativeRootDir = (0, node_path_1.relative)(tsConfig.options.rootDir, (0, node_path_1.join)(workspaceRoot, config.project.root));
+                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(tsConfig.options.outDir, relativeRootDir, `*.tsbuildinfo`), workspaceRoot, config.project));
             }
             else if (emitDeclarationOnly) {
                 // https://www.typescriptlang.org/tsconfig#tsBuildInfoFile
-                const name = config.basenameNoExt;
-                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(tsconfig.options.outDir, `${name}.tsbuildinfo`), workspaceRoot, config.project));
+                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(tsConfig.options.outDir, `${configBaseNameNoExt}.tsbuildinfo`), workspaceRoot, config.project));
             }
         }
-        else if (tsconfig.raw?.include?.length ||
-            tsconfig.raw?.files?.length ||
-            (!tsconfig.raw?.include && !tsconfig.raw?.files)) {
+        else if (tsConfig.raw?.include?.length ||
+            tsConfig.raw?.files?.length ||
+            (!tsConfig.raw?.include && !tsConfig.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'));
@@ -534,10 +546,9 @@ function getOutputs(config, tsConfig, internalProjectReferences, workspaceRoot,
             outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.d.cts.map'));
             outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.d.mts.map'));
             // https://www.typescriptlang.org/tsconfig#tsBuildInfoFile
-            const name = config.basenameNoExt;
             outputs.add(tsConfig.options.tsBuildInfoFile
                 ? pathToInputOrOutput(tsConfig.options.tsBuildInfoFile, workspaceRoot, config.project)
-                : (0, devkit_1.joinPathFragments)('{projectRoot}', `${name}.tsbuildinfo`));
+                : (0, devkit_1.joinPathFragments)('{projectRoot}', `${configBaseNameNoExt}.tsbuildinfo`));
         }
     });
     return Array.from(outputs);
@@ -612,33 +623,35 @@ function resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, projec
     }
     return projectReferences;
 }
-function hasExternalProjectReferences(tsConfigPath, tsConfig, workspaceRoot, project, cache, seen = new Set()) {
-    if (!tsConfig.projectReferences?.length) {
-        return false;
-    }
-    seen.add(tsConfigPath);
-    for (const ref of tsConfig.projectReferences) {
-        let refConfigPath = ref.path;
-        if (seen.has(refConfigPath)) {
-            continue;
-        }
-        if (!(0, node_fs_1.existsSync)(refConfigPath)) {
-            continue;
-        }
-        if (!refConfigPath.endsWith('.json')) {
-            refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
-        }
-        const refContext = getConfigContext(refConfigPath, workspaceRoot, cache);
-        if (isExternalProjectReference(refContext, project, workspaceRoot, cache)) {
-            return true;
-        }
-        const refTsConfig = retrieveTsConfigFromCache(refConfigPath, workspaceRoot, cache);
-        const result = hasExternalProjectReferences(refConfigPath, refTsConfig, workspaceRoot, project, cache, seen);
-        if (result) {
-            return true;
+/**
+ * Collects config file paths from external project references, including their
+ * extended config files. It checks the root tsconfig and all internal project
+ * references for their direct external references.
+ */
+function getExternalProjectReferenceConfigFiles(tsConfig, internalProjectReferences, workspaceRoot, project, cache, existingConfigFiles) {
+    const externalRefs = {};
+    // Collect direct external references from the root tsconfig
+    resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, project, cache, externalRefs);
+    // Collect external references from internal project references
+    for (const refTsConfig of Object.values(internalProjectReferences)) {
+        resolveShallowExternalProjectReferences(refTsConfig, workspaceRoot, project, cache, externalRefs);
+    }
+    const result = [];
+    const seen = new Set();
+    for (const [refConfigPath, refTsConfig] of Object.entries(externalRefs)) {
+        if (!existingConfigFiles.has(refConfigPath) && !seen.has(refConfigPath)) {
+            result.push(refConfigPath);
+            seen.add(refConfigPath);
+        }
+        const extendedFiles = getExtendedConfigFiles(refTsConfig, workspaceRoot, cache);
+        for (const extFile of extendedFiles.files) {
+            if (!existingConfigFiles.has(extFile) && !seen.has(extFile)) {
+                result.push(extFile);
+                seen.add(extFile);
+            }
         }
     }
-    return false;
+    return result;
 }
 function isExternalProjectReference(refConfig, project, workspaceRoot, cache) {
     const owner = cache.configOwners.get(refConfig.relativePath);