@nx/js 24.0.0-beta.2 → 24.0.0-beta.4

package/dist/src/plugins/typescript/plugin.js

@@ -7,6 +7,9 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const picomatch = require("picomatch");
 const util_1 = require("./util");
+const typecheck_target_1 = require("./typecheck-target");
+const build_typechecks_1 = require("./build-typechecks");
+const ts_solution_setup_1 = require("../../utils/typescript/ts-solution-setup");
 let ts;
 const resolvedTypescriptPaths = {};
 function resolveTypescriptPath(projectRoot, workspaceRoot) {
@@ -119,14 +122,16 @@ exports.createNodesV2 = [
             projectContexts: new Map(),
             configContexts: new Map(),
             referenceExpansionCache: new Map(),
+            siblingFiles: new Map(),
         });
         const cache = cacheStore.get(cacheKey);
         initializeTsConfigCache(configFilePaths, context.workspaceRoot, cache);
         const normalizedOptions = normalizePluginOptions(options);
+        const isUsingTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(new internal_1.FsTree(context.workspaceRoot, false));
         const packageManager = (0, devkit_1.detectPackageManager)(context.workspaceRoot);
         const pmc = (0, devkit_1.getPackageManagerCommand)(packageManager);
         const lockFileName = (0, internal_1.getLockFileName)(packageManager);
-        const { configFilePaths: validConfigFilePaths, hashes, projectRoots, } = await resolveValidConfigFilesAndHashes(configFilePaths, normalizedOptions, optionsHash, context, cache, lockFileName);
+        const { configFilePaths: validConfigFilePaths, hashes, projectRoots, } = await resolveValidConfigFilesAndHashes(configFilePaths, normalizedOptions, (0, internal_1.hashObject)({ options, isUsingTsSolutionSetup }), context, cache, lockFileName, isUsingTsSolutionSetup);
         try {
             return await (0, devkit_1.createNodesFromFiles)((configFilePath, options, context, idx) => {
                 const projectRoot = projectRoots[idx];
@@ -134,7 +139,7 @@ exports.createNodesV2 = [
                 const targetsCacheKey = `${hash}_${configFilePath}`;
                 const absolutePath = (0, node_path_1.join)(context.workspaceRoot, configFilePath);
                 const configContext = getConfigContext(absolutePath, context.workspaceRoot, cache);
-                targetsCache[targetsCacheKey] ??= buildTscTargets(configContext, options, context, validConfigFilePaths, cache, pmc);
+                targetsCache[targetsCacheKey] ??= buildTscTargets(configContext, options, context, validConfigFilePaths, cache, pmc, isUsingTsSolutionSetup);
                 const { targets } = targetsCache[targetsCacheKey];
                 return {
                     projects: {
@@ -159,7 +164,7 @@ exports.createNodesV2 = [
     },
 ];
 exports.createNodes = exports.createNodesV2;
-async function resolveValidConfigFilesAndHashes(configFilePaths, options, optionsHash, context, cache, lockFileName) {
+async function resolveValidConfigFilesAndHashes(configFilePaths, options, optionsHash, context, cache, lockFileName, isUsingTsSolutionSetup) {
     const lockFileHash = (0, internal_1.hashFile)((0, node_path_1.join)(context.workspaceRoot, lockFileName)) ?? '';
     const validConfigFilePaths = [];
     const hashes = [];
@@ -180,7 +185,13 @@ async function resolveValidConfigFilesAndHashes(configFilePaths, options, option
         }
         projectRoots.push(projectRoot);
         validConfigFilePaths.push(configFilePath);
-        hashes.push(await getConfigFileHash(configFilePath, context.workspaceRoot, configContext.project, optionsHash, lockFileHash, cache));
+        const configFileHash = await getConfigFileHash(configFilePath, context.workspaceRoot, configContext.project, optionsHash, lockFileHash, cache);
+        hashes.push(isUsingTsSolutionSetup
+            ? configFileHash
+            : (0, devkit_1.hashArray)([
+                configFileHash,
+                ...getNoEmitTypecheckHashInputs(configContext.project, context.workspaceRoot, cache),
+            ]));
     }
     return { configFilePaths: validConfigFilePaths, hashes, projectRoots };
 }
@@ -226,7 +237,7 @@ function checkIfConfigFileShouldBeProject(config, cache) {
         return false;
     }
     // Do not create a project if package.json and project.json isn't there.
-    const siblingFiles = (0, node_fs_1.readdirSync)(config.project.absolute);
+    const siblingFiles = readSiblingFiles(config.project, cache);
     if (!siblingFiles.includes('package.json') &&
         !siblingFiles.includes('project.json')) {
         return false;
@@ -247,7 +258,7 @@ function checkIfConfigFileShouldBeProject(config, cache) {
     }
     return true;
 }
-function buildTscTargets(config, options, context, configFiles, cache, pmc) {
+function buildTscTargets(config, options, context, configFiles, cache, pmc, isUsingTsSolutionSetup) {
     const targets = {};
     const namedInputs = (0, internal_1.getNamedInputs)(config.project.root, context);
     const tsConfig = retrieveTsConfigFromCache(config.absolutePath, context.workspaceRoot, cache);
@@ -259,18 +270,28 @@ function buildTscTargets(config, options, context, configFiles, cache, pmc) {
         const externalProjectReferences = resolveShallowExternalProjectReferences(tsConfig, context.workspaceRoot, config.project, cache);
         const targetName = options.typecheck.targetName;
         const compiler = options.compiler;
-        if (!targets[targetName]) {
-            let command = `${compiler} --build ${options.typecheck.configName} --emitDeclarationOnly${options.verboseOutput ? ' --verbose' : ''}`;
-            if (tsConfig.options.noEmit ||
-                Object.values(internalProjectReferences).some((ref) => ref.options.noEmit) ||
-                Object.values(externalProjectReferences).some((ref) => ref.options.noEmit)) {
-                // `tsc --build` does not work with `noEmit: true`
-                command = `echo "The 'typecheck' target is disabled because one or more project references set 'noEmit: true' in their tsconfig. Remove this property to resolve this issue."`;
+        // `tsc --build` needs composite projects, so other setups check without
+        // emitting, and skip projects whose build already type-checks.
+        if (!isUsingTsSolutionSetup) {
+            const siblingFiles = readSiblingFiles(config.project, cache);
+            if (!(0, build_typechecks_1.buildTypechecksProject)(siblingFiles, readProjectTargets(config.project.absolute, siblingFiles))) {
+                targets[targetName] = (0, typecheck_target_1.createTypecheckTarget)({
+                    mode: 'noEmit',
+                    projectRoot: config.project.normalized,
+                    pmc,
+                    tsConfig: (0, typecheck_target_1.selectTypecheckTsConfig)(siblingFiles.filter((file) => /^tsconfig.*\.json$/.test(file))),
+                    compiler,
+                    // Like the framework targets it replaces: `{workspaceRoot}` inputs
+                    // would mark the project affected by any root tsconfig change.
+                    namedInputs,
+                });
             }
-            const dependsOn = [`^${targetName}`];
+        }
+        else if (!targets[targetName]) {
+            let buildTargetName;
             if (options.build && targets[options.build.targetName]) {
                 // we already processed and have a build target
-                dependsOn.unshift(options.build.targetName);
+                buildTargetName = options.build.targetName;
             }
             else if (options.build) {
                 // check if the project will have a build target
@@ -278,29 +299,29 @@ function buildTscTargets(config, options, context, configFiles, cache, pmc) {
                 if (configFiles.some((f) => f === buildConfigPath) &&
                     (options.build.skipBuildCheck ||
                         (0, util_1.isValidPackageJsonBuildConfig)(retrieveTsConfigFromCache(buildConfigPath, context.workspaceRoot, cache), context.workspaceRoot, config.project.root))) {
-                    dependsOn.unshift(options.build.targetName);
+                    buildTargetName = options.build.targetName;
                 }
             }
-            targets[targetName] = {
-                dependsOn,
-                command,
-                options: { cwd: config.project.normalized },
-                cache: true,
+            const target = (0, typecheck_target_1.createTypecheckTarget)({
+                mode: 'build',
+                projectRoot: config.project.normalized,
+                pmc,
+                tsConfig: options.typecheck.configName,
+                compiler,
+                targetName,
+                buildTargetName,
+                verboseOutput: options.verboseOutput,
                 inputs: getInputs(namedInputs, config, tsConfig, internalProjectReferences, context.workspaceRoot, cache),
                 outputs: getOutputs(config, tsConfig, internalProjectReferences, context.workspaceRoot, 
                 /* emitDeclarationOnly */ true),
-                syncGenerators: ['@nx/js:typescript-sync'],
-                metadata: {
-                    technologies: ['typescript'],
-                    description: 'Runs type-checking for the project.',
-                    help: {
-                        command: `${pmc.exec} ${compiler} --build --help`,
-                        example: {
-                            args: ['--force'],
-                        },
-                    },
-                },
-            };
+            });
+            if (tsConfig.options.noEmit ||
+                Object.values(internalProjectReferences).some((ref) => ref.options.noEmit) ||
+                Object.values(externalProjectReferences).some((ref) => ref.options.noEmit)) {
+                // `tsc --build` does not work with `noEmit: true`
+                target.command = `echo "The 'typecheck' target is disabled because one or more project references set 'noEmit: true' in their tsconfig. Remove this property to resolve this issue."`;
+            }
+            targets[targetName] = target;
         }
     }
     // Build target
@@ -313,7 +334,7 @@ function buildTscTargets(config, options, context, configFiles, cache, pmc) {
         const compiler = options.compiler;
         targets[targetName] = {
             dependsOn: [`^${targetName}`],
-            command: `${compiler} --build ${options.build.configName}${options.verboseOutput ? ' --verbose' : ''}`,
+            command: `${compiler} --build${(0, typecheck_target_1.getTsConfigArg)(options.build.configName)}${options.verboseOutput ? ' --verbose' : ''}`,
             options: { cwd: config.project.normalized },
             cache: true,
             inputs: getInputs(namedInputs, config, tsConfig, internalProjectReferences, context.workspaceRoot, cache),
@@ -339,6 +360,48 @@ function buildTscTargets(config, options, context, configFiles, cache, pmc) {
     }
     return { targets };
 }
+/**
+ * Files that decide the `noEmit` typecheck target: the sibling tsconfigs and
+ * bundler configs by name, and `project.json` by content.
+ */
+function getNoEmitTypecheckHashInputs(project, workspaceRoot, cache) {
+    const siblingFiles = readSiblingFiles(project, cache);
+    return [
+        ...siblingFiles
+            .filter((file) => /^(tsconfig.*\.json|(webpack|rspack|rollup)\.config\..+)$/.test(file))
+            .sort(),
+        ...(siblingFiles.includes('project.json')
+            ? [
+                getFileHash((0, node_path_1.join)(project.absolute, 'project.json'), workspaceRoot, cache),
+            ]
+            : []),
+    ];
+}
+function readSiblingFiles(project, cache) {
+    let files = cache.siblingFiles.get(project.absolute);
+    if (!files) {
+        files = (0, node_fs_1.readdirSync)(project.absolute);
+        cache.siblingFiles.set(project.absolute, files);
+    }
+    return files;
+}
+function readProjectTargets(projectRoot, siblingFiles) {
+    return {
+        ...readTargets(projectRoot, siblingFiles, 'package.json', (json) => json.nx?.targets),
+        ...readTargets(projectRoot, siblingFiles, 'project.json', (json) => json.targets),
+    };
+}
+function readTargets(projectRoot, siblingFiles, file, getTargets) {
+    if (!siblingFiles.includes(file)) {
+        return undefined;
+    }
+    try {
+        return getTargets((0, devkit_1.readJsonFile)((0, node_path_1.join)(projectRoot, file)));
+    }
+    catch {
+        return undefined;
+    }
+}
 function getInputs(namedInputs, config, tsConfig, internalProjectReferences, workspaceRoot, cache) {
     const configFiles = new Set();
     // TODO(leo): temporary disable external dependencies until we support hashing
@@ -983,15 +1046,21 @@ function getFileHash(filePath, workspaceRoot, cache) {
     const relativePath = posixRelative(workspaceRoot, filePath);
     if (!cache.fileHashes[relativePath]) {
         const content = readFile(filePath, workspaceRoot, cache);
-        cache.fileHashes[relativePath] = (0, devkit_1.hashArray)([content]);
+        cache.fileHashes[relativePath] = (0, devkit_1.hashArray)([content ?? '<missing>']);
     }
     return cache.fileHashes[relativePath];
 }
+/**
+ * Returns `undefined` for a missing file, as `ts.sys.readFile` does, so a
+ * tsconfig extending a deleted file is reported by TypeScript instead of
+ * throwing.
+ */
 function readFile(filePath, workspaceRoot, cache) {
     const relativePath = posixRelative(workspaceRoot, filePath);
-    if (!cache.rawFiles[relativePath]) {
-        const content = (0, node_fs_1.readFileSync)(filePath, 'utf8');
-        cache.rawFiles[relativePath] = content;
+    if (!(relativePath in cache.rawFiles)) {
+        cache.rawFiles[relativePath] = (0, node_fs_1.existsSync)(filePath)
+            ? (0, node_fs_1.readFileSync)(filePath, 'utf8')
+            : undefined;
     }
     return cache.rawFiles[relativePath];
 }

package/dist/src/plugins/typescript/typecheck-target.d.ts

@@ -0,0 +1,54 @@
+import type { getPackageManagerCommand, TargetConfiguration } from '@nx/devkit';
+export interface TypecheckTargetOptions {
+    /**
+     * `build` runs `tsc --build --emitDeclarationOnly` for TS solution setups.
+     * `noEmit` runs `tsc -p <tsconfig> --noEmit`.
+     */
+    mode: 'build' | 'noEmit';
+    /**
+     * Project root, used as the command's cwd.
+     */
+    projectRoot: string;
+    pmc: ReturnType<typeof getPackageManagerCommand>;
+    /**
+     * Defaults to `tsconfig.json`, which is left out of the command.
+     */
+    tsConfig?: string;
+    /**
+     * Defaults to `tsc`.
+     */
+    compiler?: string;
+    /**
+     * Name of the typecheck target, for the dependency on referenced projects
+     * in `build` mode. Defaults to `typecheck`.
+     */
+    targetName?: string;
+    /**
+     * The project's build target, which `build` mode runs first.
+     */
+    buildTargetName?: string;
+    /**
+     * Defaults to the `production` (or `default`) named input plus the
+     * compiler package.
+     */
+    inputs?: TargetConfiguration['inputs'];
+    namedInputs?: Record<string, unknown>;
+    outputs?: string[];
+    technologies?: string[];
+    verboseOutput?: boolean;
+}
+/**
+ * Builds a `typecheck` target. Plugins that infer a `tsc` one share this
+ * shape so it stays compatible with the one `@nx/js/typescript` infers.
+ */
+export declare function createTypecheckTarget(options: TypecheckTargetOptions): TargetConfiguration;
+/**
+ * The tsconfig a `noEmit` typecheck target should check, from the files next
+ * to the project's config: the app, then the lib, then the root tsconfig.
+ */
+export declare function selectTypecheckTsConfig(tsConfigFiles: string[]): string | undefined;
+/**
+ * ` <tsconfig>` for a tsc command, or an empty string for `tsconfig.json`,
+ * which tsc reads by default.
+ */
+export declare function getTsConfigArg(tsConfig: string | undefined): string;

package/dist/src/plugins/typescript/typecheck-target.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTypecheckTarget = createTypecheckTarget;
+exports.selectTypecheckTsConfig = selectTypecheckTsConfig;
+exports.getTsConfigArg = getTsConfigArg;
+const DEFAULT_TSCONFIG = 'tsconfig.json';
+/**
+ * Builds a `typecheck` target. Plugins that infer a `tsc` one share this
+ * shape so it stays compatible with the one `@nx/js/typescript` infers.
+ */
+function createTypecheckTarget(options) {
+    const compiler = options.compiler ?? 'tsc';
+    const tsConfigArg = getTsConfigArg(options.tsConfig);
+    const target = {
+        command: options.mode === 'build'
+            ? `${compiler} --build${tsConfigArg} --emitDeclarationOnly${options.verboseOutput ? ' --verbose' : ''}`
+            : `${compiler}${tsConfigArg ? ` -p${tsConfigArg}` : ''} --noEmit`,
+        options: { cwd: options.projectRoot },
+        cache: true,
+        inputs: options.inputs ??
+            getDefaultTypecheckInputs(options.namedInputs ?? {}, compiler),
+        metadata: {
+            technologies: options.technologies ?? ['typescript'],
+            description: 'Runs type-checking for the project.',
+            help: options.mode === 'build'
+                ? {
+                    command: `${options.pmc.exec} ${compiler} --build --help`,
+                    example: { args: ['--force'] },
+                }
+                : {
+                    command: `${options.pmc.exec} ${compiler}${tsConfigArg ? ` -p${tsConfigArg}` : ''} --help`,
+                    example: { options: { noEmit: true } },
+                },
+        },
+    };
+    if (options.outputs) {
+        target.outputs = options.outputs;
+    }
+    if (options.mode === 'build') {
+        target.dependsOn = [`^${options.targetName ?? 'typecheck'}`];
+        if (options.buildTargetName) {
+            target.dependsOn.unshift(options.buildTargetName);
+        }
+        target.syncGenerators = ['@nx/js:typescript-sync'];
+    }
+    return target;
+}
+/**
+ * The tsconfig a `noEmit` typecheck target should check, from the files next
+ * to the project's config: the app, then the lib, then the root tsconfig.
+ */
+function selectTypecheckTsConfig(tsConfigFiles) {
+    return (['tsconfig.app.json', 'tsconfig.lib.json', DEFAULT_TSCONFIG].find((file) => tsConfigFiles.includes(file)) ?? tsConfigFiles.find((file) => SHELL_SAFE_TSCONFIG.test(file)));
+}
+// The name goes unquoted into a shell command.
+const SHELL_SAFE_TSCONFIG = /^tsconfig[\w.-]*\.json$/;
+/**
+ * ` <tsconfig>` for a tsc command, or an empty string for `tsconfig.json`,
+ * which tsc reads by default.
+ */
+function getTsConfigArg(tsConfig) {
+    return !tsConfig || tsConfig === DEFAULT_TSCONFIG ? '' : ` ${tsConfig}`;
+}
+function getDefaultTypecheckInputs(namedInputs, compiler) {
+    return [
+        ...('production' in namedInputs
+            ? ['production', '^production']
+            : ['default', '^default']),
+        { externalDependencies: getCompilerPackages(compiler) },
+    ];
+}
+function getCompilerPackages(compiler) {
+    switch (compiler) {
+        case 'tsgo':
+            return ['@typescript/native-preview'];
+        case 'vue-tsc':
+            return ['vue-tsc', 'typescript'];
+        default:
+            return ['typescript'];
+    }
+}

package/dist/src/utils/add-linting-to-project.d.ts

@@ -6,7 +6,6 @@ export interface AddLintingToProjectOptions {
     project: string;
     skipPackageJson?: boolean;
     keepExistingVersions?: boolean;
-    addPlugin?: boolean;
     /** ESLint-only. Ignored by other linters. */
     tsConfigPaths?: string[];
     unitTestRunner?: string;
@@ -15,7 +14,6 @@ export interface AddLintingToProjectOptions {
     /** ESLint-only. Ignored by other linters. */
     enableTypedLinting?: boolean;
     /** ESLint-only. Oxlint is inference-only, so it writes no explicit target. */
-    addExplicitTargets?: boolean;
     /**
      * ESLint-only. The `@nx/dependency-checks` rule lints `package.json`, which
      * Oxlint cannot read.

package/dist/src/utils/add-linting-to-project.js

@@ -60,7 +60,6 @@ async function addLintingToProject(tree, options) {
             skipFormat: true,
             skipPackageJson: options.skipPackageJson,
             keepExistingVersions: options.keepExistingVersions,
-            // No `addPlugin`: `@nx/oxlint` is inference-only, so it always registers.
         });
     }
     if (linter === 'eslint') {
@@ -72,12 +71,10 @@ async function addLintingToProject(tree, options) {
             unitTestRunner: options.unitTestRunner,
             rootProject: options.rootProject,
             enableTypedLinting: options.enableTypedLinting,
-            addExplicitTargets: options.addExplicitTargets,
             addPackageJsonDependencyChecks: options.addPackageJsonDependencyChecks,
             skipFormat: true,
             skipPackageJson: options.skipPackageJson,
             keepExistingVersions: options.keepExistingVersions,
-            addPlugin: options.addPlugin,
         });
     }
     // Spelling ESLint out as its own branch rather than letting it be the

package/dist/src/utils/swc/compile-swc.d.ts

@@ -1,6 +1,8 @@
 import { ExecutorContext } from '@nx/devkit';
 import { NormalizedSwcExecutorOptions } from '../schema';
+import { TypeCheckOptions } from '../typescript/run-type-check';
 export declare function getSwcCmd({ swcCliOptions: { swcrcPath, destPath, stripLeadingPaths }, root, projectRoot, sourceRoot, main, }: NormalizedSwcExecutorOptions, watch?: boolean): string;
+export declare function getTypeCheckOptions(normalizedOptions: NormalizedSwcExecutorOptions): TypeCheckOptions;
 export declare function compileSwc(context: ExecutorContext, normalizedOptions: NormalizedSwcExecutorOptions, postCompilationCallback: () => Promise<void>): Promise<{
     success: boolean;
     outfile?: undefined;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSwcCmd = getSwcCmd;
+exports.getTypeCheckOptions = getTypeCheckOptions;
 exports.compileSwc = compileSwc;
 exports.compileSwcWatch = compileSwcWatch;
 const devkit_1 = require("@nx/devkit");
@@ -45,7 +46,7 @@ function getTypeCheckOptions(normalizedOptions) {
         tsConfigPath: tsConfig,
         outDir: outputPath,
         workspaceRoot: root,
-        rootDir: inputDir,
+        rootDir: (0, node_path_1.join)(root, inputDir),
     };
     if (watch) {
         typeCheckOptions.incremental = true;

package/dist/src/utils/typescript/add-typescript-plugin.d.ts

@@ -0,0 +1,22 @@
+import { type Tree } from '@nx/devkit';
+export declare function addTypescriptPlugin(tree: Tree, updatePackageScripts?: boolean): Promise<void>;
+/**
+ * Registers `@nx/js/typescript` in a workspace where no registration of it
+ * infers `typecheck` yet, adding a typecheck-only entry next to an existing
+ * unscoped one. Outside TS solution setups it only infers `typecheck`. Callers decide
+ * whether inference plugins are in use. Pass `frameworkPlugin` when that
+ * plugin still infers `typecheck` for some projects, so its target wins.
+ */
+export declare function ensureTypescriptPlugin(tree: Tree, updatePackageScripts?: boolean, frameworkPlugin?: string): Promise<void>;
+/**
+ * Registers `@nx/js/typescript`, with only its typecheck target, in a
+ * workspace where `frameworkPlugin` no longer infers `typecheck`. Reuses the
+ * framework plugin's `typecheckTargetName` and a `tsgo` compiler, and skips
+ * workspaces where `@nx/js/typescript` already infers it or where
+ * `typecheckTargetName` is `false`. With
+ * `removeTypecheckTargetName`, the option is also dropped from the framework
+ * plugin's registrations. Returns whether nx.json changed.
+ */
+export declare function registerTypescriptPluginForTypecheck(tree: Tree, frameworkPlugin: string, { removeTypecheckTargetName }?: {
+    removeTypecheckTargetName?: boolean;
+}): boolean;

package/dist/src/utils/typescript/add-typescript-plugin.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addTypescriptPlugin = addTypescriptPlugin;
+exports.ensureTypescriptPlugin = ensureTypescriptPlugin;
+exports.registerTypescriptPluginForTypecheck = registerTypescriptPluginForTypecheck;
+const internal_1 = require("@nx/devkit/internal");
+const devkit_1 = require("@nx/devkit");
+const plugin_1 = require("../../plugins/typescript/plugin");
+const ts_solution_setup_1 = require("./ts-solution-setup");
+async function addTypescriptPlugin(tree, updatePackageScripts) {
+    await (0, internal_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/js/typescript', plugin_1.createNodesV2, {
+        typecheck: TYPECHECK_OPTIONS,
+        build: [
+            {
+                targetName: 'build',
+                configName: 'tsconfig.lib.json',
+                buildDepsName: 'build-deps',
+                watchDepsName: 'watch-deps',
+            },
+            {
+                targetName: 'tsc:build',
+                configName: 'tsconfig.lib.json',
+                buildDepsName: 'tsc:build-deps',
+                watchDepsName: 'tsc:watch-deps',
+            },
+            {
+                targetName: 'tsc-build',
+                configName: 'tsconfig.lib.json',
+                buildDepsName: 'tsc-build-deps',
+                watchDepsName: 'tsc-watch-deps',
+            },
+        ],
+    }, updatePackageScripts);
+}
+const TYPECHECK_OPTIONS = [
+    { targetName: 'typecheck' },
+    { targetName: 'tsc:typecheck' },
+    { targetName: 'tsc-typecheck' },
+];
+/**
+ * Registers `@nx/js/typescript` in a workspace where no registration of it
+ * infers `typecheck` yet, adding a typecheck-only entry next to an existing
+ * unscoped one. Outside TS solution setups it only infers `typecheck`. Callers decide
+ * whether inference plugins are in use. Pass `frameworkPlugin` when that
+ * plugin still infers `typecheck` for some projects, so its target wins.
+ */
+async function ensureTypescriptPlugin(tree, updatePackageScripts, frameworkPlugin) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (nxJson?.plugins?.some(infersTypecheck)) {
+        return;
+    }
+    if (nxJson?.plugins?.some((p) => typeof p !== 'string' && p.plugin === '@nx/js/typescript' && !p.include)) {
+        // `addPlugin` skips workspaces that have an unscoped registration.
+        nxJson.plugins.push({
+            plugin: '@nx/js/typescript',
+            options: { typecheck: { targetName: 'typecheck' } },
+        });
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+    else if ((0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree)) {
+        await addTypescriptPlugin(tree, updatePackageScripts);
+    }
+    else {
+        await (0, internal_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/js/typescript', plugin_1.createNodesV2, { typecheck: TYPECHECK_OPTIONS }, updatePackageScripts);
+    }
+    if (frameworkPlugin) {
+        const updated = (0, devkit_1.readNxJson)(tree);
+        if (moveTypescriptPluginBefore(updated.plugins, frameworkPlugin)) {
+            (0, devkit_1.updateNxJson)(tree, updated);
+        }
+    }
+}
+/**
+ * Registers `@nx/js/typescript`, with only its typecheck target, in a
+ * workspace where `frameworkPlugin` no longer infers `typecheck`. Reuses the
+ * framework plugin's `typecheckTargetName` and a `tsgo` compiler, and skips
+ * workspaces where `@nx/js/typescript` already infers it or where
+ * `typecheckTargetName` is `false`. With
+ * `removeTypecheckTargetName`, the option is also dropped from the framework
+ * plugin's registrations. Returns whether nx.json changed.
+ */
+function registerTypescriptPluginForTypecheck(tree, frameworkPlugin, { removeTypecheckTargetName = false } = {}) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (!nxJson?.plugins?.length) {
+        return false;
+    }
+    const frameworkRegistrations = nxJson.plugins.filter((p) => getPluginName(p) === frameworkPlugin);
+    const typecheckOptions = frameworkRegistrations
+        .map((p) => (typeof p === 'string' ? {} : (p.options ?? {})))
+        .find((options) => options.typecheckTargetName !== false);
+    const targetName = typecheckOptions
+        ? (typecheckOptions.typecheckTargetName ?? 'typecheck')
+        : undefined;
+    let changed = false;
+    if (removeTypecheckTargetName) {
+        for (const p of frameworkRegistrations) {
+            const options = typeof p === 'string'
+                ? undefined
+                : p.options;
+            if (options && 'typecheckTargetName' in options) {
+                delete options['typecheckTargetName'];
+                changed = true;
+            }
+        }
+    }
+    if (targetName && !nxJson.plugins.some(infersTypecheck)) {
+        nxJson.plugins.push({
+            plugin: '@nx/js/typescript',
+            options: {
+                typecheck: { targetName },
+                ...(typecheckOptions.compiler === 'tsgo' ? { compiler: 'tsgo' } : {}),
+            },
+        });
+        moveTypescriptPluginBefore(nxJson.plugins, frameworkPlugin);
+        changed = true;
+    }
+    if (changed) {
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+    return changed;
+}
+/**
+ * Plugins registered later override same-named targets, so `@nx/js/typescript`
+ * goes before a framework plugin that still infers `typecheck`.
+ */
+function moveTypescriptPluginBefore(plugins, frameworkPlugin) {
+    const tsIndex = plugins.findIndex(infersTypecheck);
+    const frameworkIndex = plugins.findIndex((p) => getPluginName(p) === frameworkPlugin);
+    if (tsIndex === -1 || frameworkIndex === -1 || tsIndex < frameworkIndex) {
+        return false;
+    }
+    const [tsPlugin] = plugins.splice(tsIndex, 1);
+    plugins.splice(frameworkIndex, 0, tsPlugin);
+    return true;
+}
+// Scoped build-only registrations, like `@nx/node`'s tsc apps, set `typecheck: false`.
+function infersTypecheck(plugin) {
+    return (getPluginName(plugin) === '@nx/js/typescript' &&
+        (typeof plugin === 'string' ||
+            plugin.options?.typecheck !==
+                false));
+}
+function getPluginName(plugin) {
+    return typeof plugin === 'string' ? plugin : plugin.plugin;
+}

package/dist/src/utils/typescript/ts-solution-setup.d.ts

@@ -2,7 +2,7 @@ import { type ProjectConfiguration, type Tree } from '@nx/devkit';
 import type { JsonInput } from '@nx/devkit/internal';
 export declare const TS_SOLUTION_SETUP_TSCONFIG_INPUT: JsonInput;
 export declare function isUsingTypeScriptPlugin(tree: Tree): boolean;
-export declare function shouldConfigureTsSolutionSetup(tree: Tree, addPlugins: boolean, addTsPlugin?: boolean): boolean;
+export declare function shouldConfigureTsSolutionSetup(tree: Tree, addTsPlugin?: boolean): boolean;
 export declare function isUsingTsSolutionSetup(tree?: Tree): boolean;
 export declare function assertNotUsingTsSolutionSetup(tree: Tree, pluginName: string, generatorName: string): void;
 export declare function findRuntimeTsConfigName(projectRoot: string, tree?: Tree): string | null;

package/dist/src/utils/typescript/ts-solution-setup.js

@@ -28,19 +28,10 @@ function isUsingTypeScriptPlugin(tree) {
         ? p === '@nx/js/typescript'
         : p.plugin === '@nx/js/typescript') ?? false);
 }
-function shouldConfigureTsSolutionSetup(tree, addPlugins, addTsPlugin) {
+function shouldConfigureTsSolutionSetup(tree, addTsPlugin) {
     if (addTsPlugin !== undefined) {
         return addTsPlugin;
     }
-    if (addPlugins === undefined) {
-        const nxJson = (0, devkit_1.readNxJson)(tree);
-        addPlugins =
-            process.env.NX_ADD_PLUGINS !== 'false' &&
-                nxJson.useInferencePlugins !== false;
-    }
-    if (!addPlugins) {
-        return false;
-    }
     if (!(0, package_manager_workspaces_1.isUsingPackageManagerWorkspaces)(tree)) {
         return false;
     }