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

package/src/generators/library/utils/package-manager-workspaces.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectPackageManagerWorkspaceStateWarningTask = getProjectPackageManagerWorkspaceStateWarningTask;
+const devkit_1 = require("@nx/devkit");
+const semver_1 = require("semver");
+function getProjectPackageManagerWorkspaceStateWarningTask(projectPackageManagerWorkspaceState, workspaceRoot) {
+    return () => {
+        const packageManager = (0, devkit_1.detectPackageManager)(workspaceRoot);
+        let packageManagerWorkspaceSetupDocs;
+        if (packageManager === 'pnpm') {
+            packageManagerWorkspaceSetupDocs =
+                'https://pnpm.io/workspaces and https://pnpm.io/pnpm-workspace_yaml';
+        }
+        else if (packageManager === 'yarn') {
+            const yarnVersion = (0, devkit_1.getPackageManagerVersion)(packageManager, workspaceRoot);
+            if ((0, semver_1.lt)(yarnVersion, '2.0.0')) {
+                packageManagerWorkspaceSetupDocs =
+                    'https://classic.yarnpkg.com/lang/en/docs/workspaces/';
+            }
+            else {
+                packageManagerWorkspaceSetupDocs =
+                    'https://yarnpkg.com/features/workspaces';
+            }
+        }
+        else if (packageManager === 'npm') {
+            packageManagerWorkspaceSetupDocs =
+                'https://docs.npmjs.com/cli/v10/using-npm/workspaces';
+        }
+        else if (packageManager === 'bun') {
+            packageManagerWorkspaceSetupDocs =
+                'https://bun.sh/docs/install/workspaces';
+        }
+        if (projectPackageManagerWorkspaceState === 'no-workspaces') {
+            devkit_1.output.warn({
+                title: `The package manager workspaces feature is not enabled in the workspace`,
+                bodyLines: [
+                    'You must enable the package manager workspaces feature to use the "@nx/js/typescript" plugin.',
+                    `Read more about the ${packageManager} workspaces feature and how to set it up at ${packageManagerWorkspaceSetupDocs}.`,
+                ],
+            });
+        }
+        else if (projectPackageManagerWorkspaceState === 'excluded') {
+            devkit_1.output.warn({
+                title: `The project is not included in the package manager workspaces configuration`,
+                bodyLines: [
+                    'Please add it to the workspace configuration to use the "@nx/js/typescript" plugin.',
+                    `Read more about the ${packageManager} workspaces feature and how to set it up at ${packageManagerWorkspaceSetupDocs}.`,
+                ],
+            });
+        }
+    };
+}

package/src/generators/library/utils/plugin-registrations.d.ts

@@ -0,0 +1,3 @@
+import type { NxJsonConfiguration } from '@nx/devkit';
+export declare function ensureProjectIsIncludedInPluginRegistrations(nxJson: NxJsonConfiguration, projectRoot: string): void;
+export declare function ensureProjectIsExcludedFromPluginRegistrations(nxJson: NxJsonConfiguration, projectRoot: string): void;

package/src/generators/library/utils/plugin-registrations.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureProjectIsIncludedInPluginRegistrations = ensureProjectIsIncludedInPluginRegistrations;
+exports.ensureProjectIsExcludedFromPluginRegistrations = ensureProjectIsExcludedFromPluginRegistrations;
+const devkit_internals_1 = require("nx/src/devkit-internals");
+function ensureProjectIsIncludedInPluginRegistrations(nxJson, projectRoot) {
+    if (!nxJson.plugins?.length ||
+        !nxJson.plugins.some(isTypeScriptPluginRegistration)) {
+        return;
+    }
+    let isIncluded = false;
+    let index = 0;
+    for (const registration of nxJson.plugins) {
+        if (!isTypeScriptPluginRegistration(registration)) {
+            index++;
+            continue;
+        }
+        if (typeof registration === 'string') {
+            // if it's a string all projects are included but the are no user-specified options
+            // and the `build` task is not inferred by default, so we need to exclude it
+            nxJson.plugins[index] = {
+                plugin: '@nx/js/typescript',
+                exclude: [`${projectRoot}/*`],
+            };
+        }
+        else {
+            // check if the project would be included by the plugin registration
+            const matchingConfigFiles = (0, devkit_internals_1.findMatchingConfigFiles)([`${projectRoot}/tsconfig.json`], '**/tsconfig.json', registration.include, registration.exclude);
+            if (matchingConfigFiles.length) {
+                // it's included by the plugin registration, check if the user-specified options would result
+                // in a `build` task being inferred, if not, we need to exclude it
+                if (registration.options?.typecheck && registration.options?.build) {
+                    // it has the desired options, do nothing
+                    isIncluded = true;
+                }
+                else {
+                    // it would not have the `build` task inferred, so we need to exclude it
+                    registration.exclude ??= [];
+                    registration.exclude.push(`${projectRoot}/*`);
+                }
+            }
+            else if (registration.options?.typecheck &&
+                registration.options?.build &&
+                !registration.exclude?.length) {
+                // negative pattern are not supported by the `exclude` option so we
+                // can't update it to not exclude the project, so we only update the
+                // plugin registration if there's no `exclude` option, in which case
+                // the plugin registration should have an `include` options that doesn't
+                // include the project
+                isIncluded = true;
+                registration.include ??= [];
+                registration.include.push(`${projectRoot}/*`);
+            }
+        }
+        index++;
+    }
+    if (!isIncluded) {
+        // the project is not included by any plugin registration with an inferred `build` task,
+        // so we create a new plugin registration for it
+        nxJson.plugins.push({
+            plugin: '@nx/js/typescript',
+            include: [`${projectRoot}/*`],
+            options: {
+                typecheck: { targetName: 'typecheck' },
+                build: {
+                    targetName: 'build',
+                    configName: 'tsconfig.lib.json',
+                },
+            },
+        });
+    }
+}
+function ensureProjectIsExcludedFromPluginRegistrations(nxJson, projectRoot) {
+    if (!nxJson.plugins?.length ||
+        !nxJson.plugins.some(isTypeScriptPluginRegistration)) {
+        return;
+    }
+    let index = 0;
+    for (const registration of nxJson.plugins) {
+        if (!isTypeScriptPluginRegistration(registration)) {
+            index++;
+            continue;
+        }
+        if (typeof registration === 'string') {
+            // if it's a string, it includes all projects, so we need to exclude it
+            nxJson.plugins[index] = {
+                plugin: '@nx/js/typescript',
+                exclude: [`${projectRoot}/*`],
+            };
+        }
+        else {
+            // check if the project would be included by the plugin registration
+            const matchingConfigFiles = (0, devkit_internals_1.findMatchingConfigFiles)([`${projectRoot}/tsconfig.json`], '**/tsconfig.json', registration.include, registration.exclude);
+            if (matchingConfigFiles.length &&
+                (registration.options?.typecheck !== false ||
+                    registration.options?.build)) {
+                // the project is included by a plugin registration that infers any of the targets, so we need to exclude it
+                registration.exclude ??= [];
+                registration.exclude.push(`${projectRoot}/*`);
+            }
+        }
+        index++;
+    }
+}
+function isTypeScriptPluginRegistration(plugin) {
+    return ((typeof plugin === 'string' && plugin === '@nx/js/typescript') ||
+        (typeof plugin !== 'string' && plugin.plugin === '@nx/js/typescript'));
+}

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupVerdaccio = setupVerdaccio;
 const devkit_1 = require("@nx/devkit");
 const path = require("path");
+const ts_solution_setup_1 = require("../../utils/typescript/ts-solution-setup");
 const versions_1 = require("../../utils/versions");
 const child_process_1 = require("child_process");
 async function setupVerdaccio(tree, options) {
@@ -24,21 +25,24 @@ async function setupVerdaccio(tree, options) {
         },
     };
     if (!tree.exists('project.json')) {
+        const isUsingNewTsSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree);
         const { name } = (0, devkit_1.readJson)(tree, 'package.json');
         (0, devkit_1.updateJson)(tree, 'package.json', (json) => {
-            if (!json.nx) {
-                json.nx = {
-                    includedScripts: [],
-                };
+            json.nx ??= { includedScripts: [] };
+            if (isUsingNewTsSetup) {
+                json.nx.targets ??= {};
+                json.nx.targets['local-registry'] ??= verdaccioTarget;
             }
             return json;
         });
-        (0, devkit_1.addProjectConfiguration)(tree, name, {
-            root: '.',
-            targets: {
-                ['local-registry']: verdaccioTarget,
-            },
-        });
+        if (!isUsingNewTsSetup) {
+            (0, devkit_1.addProjectConfiguration)(tree, name, {
+                root: '.',
+                targets: {
+                    ['local-registry']: verdaccioTarget,
+                },
+            });
+        }
     }
     else {
         // use updateJson instead of updateProjectConfiguration due to unknown project name

package/src/generators/typescript-sync/typescript-sync.d.ts

@@ -1,4 +1,4 @@
 import { type Tree } from '@nx/devkit';
-import type { SyncGeneratorResult } from 'nx/src/utils/sync-generators';
+import { type SyncGeneratorResult } from 'nx/src/utils/sync-generators';
 export declare function syncGenerator(tree: Tree): Promise<SyncGeneratorResult>;
 export default syncGenerator;

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

@@ -5,6 +5,7 @@ const devkit_1 = require("@nx/devkit");
 const ignore_1 = require("ignore");
 const jsonc_parser_1 = require("jsonc-parser");
 const posix_1 = require("node:path/posix");
+const sync_generators_1 = require("nx/src/utils/sync-generators");
 const ts = require("typescript");
 const plugin_1 = require("../../plugins/typescript/plugin");
 const COMMON_RUNTIME_TS_CONFIG_FILE_NAMES = [
@@ -25,12 +26,16 @@ async function syncGenerator(tree) {
         return p.plugin === plugin_1.PLUGIN_NAME;
     });
     if (!tscPluginConfig) {
-        throw new Error(`The ${plugin_1.PLUGIN_NAME} plugin must be added to the "plugins" array in nx.json before syncing tsconfigs`);
+        throw new sync_generators_1.SyncError(`The "${plugin_1.PLUGIN_NAME}" plugin is not registered`, [
+            `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.`,
+        ]);
     }
     // Root tsconfig containing project references for the whole workspace
     const rootTsconfigPath = 'tsconfig.json';
     if (!tree.exists(rootTsconfigPath)) {
-        throw new Error(`A "tsconfig.json" file must exist in the workspace root in order to use this sync generator.`);
+        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);
@@ -93,8 +98,7 @@ async function syncGenerator(tree) {
     const collectedDependencies = new Map();
     for (const [projectName, data] of Object.entries(projectGraph.dependencies)) {
         if (!projectGraph.nodes[projectName] ||
-            projectGraph.nodes[projectName].data.root === '.' ||
-            !data.length) {
+            projectGraph.nodes[projectName].data.root === '.') {
             continue;
         }
         // Get the source project nodes for the source and target
@@ -109,9 +113,6 @@ async function syncGenerator(tree) {
         }
         // Collect the dependencies of the source project
         const dependencies = collectProjectDependencies(tree, projectName, projectGraph, collectedDependencies);
-        if (!dependencies.length) {
-            continue;
-        }
         for (const runtimeTsConfigFileName of runtimeTsConfigFileNames) {
             const runtimeTsConfigPath = (0, devkit_1.joinPathFragments)(sourceProjectNode.data.root, runtimeTsConfigFileName);
             if (!tsconfigExists(tree, rawTsconfigContentsCache, runtimeTsConfigPath)) {
@@ -128,7 +129,7 @@ async function syncGenerator(tree) {
     if (hasChanges) {
         await (0, devkit_1.formatFiles)(tree);
         return {
-            outOfSyncMessage: 'Based on the workspace project graph, some TypeScript configuration files are missing project references to the projects they depend on.',
+            outOfSyncMessage: 'Based on the workspace project graph, some TypeScript configuration files are missing project references to the projects they depend on or contain outdated project references.',
         };
     }
 }

package/src/plugins/typescript/plugin.js

@@ -292,6 +292,10 @@ function resolveInternalProjectReferences(tsConfig, workspaceRoot, projectRoot,
             // Already resolved
             continue;
         }
+        if (!(0, node_fs_1.existsSync)(refConfigPath)) {
+            // the referenced tsconfig doesn't exist, ignore it
+            continue;
+        }
         if (isExternalProjectReference(refConfigPath, workspaceRoot, projectRoot)) {
             continue;
         }
@@ -315,6 +319,10 @@ function hasExternalProjectReferences(tsConfigPath, tsConfig, workspaceRoot, pro
             // Already seen
             continue;
         }
+        if (!(0, node_fs_1.existsSync)(refConfigPath)) {
+            // the referenced tsconfig doesn't exist, ignore it
+            continue;
+        }
         if (isExternalProjectReference(refConfigPath, workspaceRoot, projectRoot)) {
             return true;
         }

package/src/utils/find-npm-dependencies.js

@@ -138,4 +138,16 @@ function collectHelperDependencies(workspaceRoot, sourceProject, projectGraph, b
                 projectGraph.externalNodes['npm:@swc/helpers'].data.version;
         }
     }
+    // For inferred targets or manually added run-commands, check if user is using `tsc` in build target.
+    if (target.executor === 'nx:run-commands' &&
+        /\btsc\b/.test(target.options.command)) {
+        const tsConfigFileName = (0, ts_config_1.getRootTsConfigFileName)();
+        if (tsConfigFileName) {
+            const tsConfig = (0, ts_config_1.readTsConfig)((0, path_1.join)(workspaceRoot, tsConfigFileName));
+            if (tsConfig?.options['importHelpers'] &&
+                projectGraph.externalNodes['npm:tslib']?.type === 'npm') {
+                npmDeps['tslib'] = projectGraph.externalNodes['npm:tslib'].data.version;
+            }
+        }
+    }
 }

package/src/utils/package-manager-workspaces.d.ts

@@ -0,0 +1,4 @@
+import { type Tree } from '@nx/devkit';
+export type ProjectPackageManagerWorkspaceState = 'included' | 'excluded' | 'no-workspaces';
+export declare function getProjectPackageManagerWorkspaceState(tree: Tree, projectRoot: string): ProjectPackageManagerWorkspaceState;
+export declare function isUsingPackageManagerWorkspaces(tree: Tree): boolean;

package/src/utils/package-manager-workspaces.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectPackageManagerWorkspaceState = getProjectPackageManagerWorkspaceState;
+exports.isUsingPackageManagerWorkspaces = isUsingPackageManagerWorkspaces;
+const devkit_1 = require("@nx/devkit");
+const minimatch_1 = require("minimatch");
+const posix_1 = require("node:path/posix");
+const package_json_1 = require("nx/src/plugins/package-json");
+function getProjectPackageManagerWorkspaceState(tree, projectRoot) {
+    if (!isUsingPackageManagerWorkspaces(tree)) {
+        return 'no-workspaces';
+    }
+    const patterns = (0, package_json_1.getGlobPatternsFromPackageManagerWorkspaces)(tree.root, (path) => (0, devkit_1.readJson)(tree, path, { expectComments: true }));
+    const isIncluded = patterns.some((p) => (0, minimatch_1.minimatch)((0, posix_1.join)(projectRoot, 'package.json'), p));
+    return isIncluded ? 'included' : 'excluded';
+}
+function isUsingPackageManagerWorkspaces(tree) {
+    return (0, devkit_1.isWorkspacesEnabled)((0, devkit_1.detectPackageManager)(tree.root), tree.root);
+}

package/src/utils/prettier.d.ts

@@ -8,3 +8,4 @@ export declare function resolveUserExistingPrettierConfig(): Promise<ExistingPre
 export declare function generatePrettierSetup(tree: Tree, options: {
     skipPackageJson?: boolean;
 }): GeneratorCallback;
+export declare function resolvePrettierConfigPath(tree: Tree): Promise<string | null>;

package/src/utils/prettier.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveUserExistingPrettierConfig = resolveUserExistingPrettierConfig;
 exports.generatePrettierSetup = generatePrettierSetup;
+exports.resolvePrettierConfigPath = resolvePrettierConfigPath;
 const devkit_1 = require("@nx/devkit");
 const versions_1 = require("./versions");
 async function resolveUserExistingPrettierConfig() {
@@ -74,3 +75,55 @@ function generatePrettierSetup(tree, options) {
         ? () => { }
         : (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { prettier: versions_1.prettierVersion });
 }
+async function resolvePrettierConfigPath(tree) {
+    let prettier;
+    try {
+        prettier = require('prettier');
+    }
+    catch {
+        return null;
+    }
+    if (prettier) {
+        const filePath = await prettier.resolveConfigFile();
+        if (filePath) {
+            return filePath;
+        }
+    }
+    if (!tree) {
+        return null;
+    }
+    // if we haven't find a config file in the file system, we try to find it in the virtual tree
+    // https://prettier.io/docs/en/configuration.html
+    const prettierrcNameOptions = [
+        '.prettierrc',
+        '.prettierrc.json',
+        '.prettierrc.yml',
+        '.prettierrc.yaml',
+        '.prettierrc.json5',
+        '.prettierrc.js',
+        '.prettierrc.cjs',
+        '.prettierrc.mjs',
+        '.prettierrc.toml',
+        'prettier.config.js',
+        'prettier.config.cjs',
+        'prettier.config.mjs',
+    ];
+    const filePath = prettierrcNameOptions.find((file) => tree.exists(file));
+    if (filePath) {
+        return filePath;
+    }
+    // check the package.json file
+    const packageJson = (0, devkit_1.readJson)(tree, 'package.json');
+    if (packageJson.prettier) {
+        return 'package.json';
+    }
+    // check the package.yaml file
+    if (tree.exists('package.yaml')) {
+        const { load } = await Promise.resolve().then(() => require('@zkochan/js-yaml'));
+        const packageYaml = load(tree.read('package.yaml', 'utf-8'));
+        if (packageYaml.prettier) {
+            return 'package.yaml';
+        }
+    }
+    return null;
+}

package/src/utils/schema.d.ts

@@ -1,39 +1,7 @@
-import type { ProjectNameAndRootFormat } from '@nx/devkit/src/generators/project-name-and-root-utils';
 import type { AssetGlob, FileInputOutput } from './assets/assets';
 import { TransformerEntry } from './typescript/types';
-// nx-ignore-next-line
-const { Linter, LinterType } = require('@nx/eslint'); // use require to import to avoid circular dependency
 
 export type Compiler = 'tsc' | 'swc';
-export type Bundler = 'swc' | 'tsc' | 'rollup' | 'vite' | 'esbuild' | 'none';
-
-export interface LibraryGeneratorSchema {
-  name: string;
-  directory?: string;
-  projectNameAndRootFormat?: ProjectNameAndRootFormat;
-  skipFormat?: boolean;
-  tags?: string;
-  skipTsConfig?: boolean;
-  skipPackageJson?: boolean;
-  includeBabelRc?: boolean;
-  unitTestRunner?: 'jest' | 'vitest' | 'none';
-  linter?: Linter | LinterType;
-  testEnvironment?: 'jsdom' | 'node';
-  importPath?: string;
-  js?: boolean;
-  strict?: boolean;
-  publishable?: boolean;
-  buildable?: boolean;
-  setParserOptionsProject?: boolean;
-  config?: 'workspace' | 'project' | 'npm-scripts';
-  compiler?: Compiler;
-  bundler?: Bundler;
-  skipTypeCheck?: boolean;
-  minimal?: boolean;
-  rootProject?: boolean;
-  simpleName?: boolean;
-  addPlugin?: boolean;
-}
 
 export interface ExecutorOptions {
   assets: Array<AssetGlob | string>;

package/src/utils/swc/add-swc-dependencies.d.ts

@@ -1,3 +1,7 @@
 import { Tree } from '@nx/devkit';
+export declare function getSwcDependencies(): {
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+};
 export declare function addSwcDependencies(tree: Tree): import("@nx/devkit").GeneratorCallback;
 export declare function addSwcRegisterDependencies(tree: Tree): import("@nx/devkit").GeneratorCallback;

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

@@ -1,16 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSwcDependencies = getSwcDependencies;
 exports.addSwcDependencies = addSwcDependencies;
 exports.addSwcRegisterDependencies = addSwcRegisterDependencies;
 const devkit_1 = require("@nx/devkit");
 const versions_1 = require("../versions");
-function addSwcDependencies(tree) {
-    return (0, devkit_1.addDependenciesToPackageJson)(tree, {
+function getSwcDependencies() {
+    const dependencies = {
         '@swc/helpers': versions_1.swcHelpersVersion,
-    }, {
+    };
+    const devDependencies = {
         '@swc/core': versions_1.swcCoreVersion,
         '@swc/cli': versions_1.swcCliVersion,
-    });
+    };
+    return { dependencies, devDependencies };
+}
+function addSwcDependencies(tree) {
+    const { dependencies, devDependencies } = getSwcDependencies();
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, dependencies, devDependencies);
 }
 function addSwcRegisterDependencies(tree) {
     return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@swc-node/register': versions_1.swcNodeVersion, '@swc/core': versions_1.swcCoreVersion });

package/src/utils/typescript/configuration.d.ts

@@ -0,0 +1,7 @@
+import type { Tree } from '@nx/devkit';
+import type { CompilerOptions } from 'typescript';
+/**
+ * Cleans up the provided compiler options to only include the options that are
+ * different or not set in the provided tsconfig file.
+ */
+export declare function getNeededCompilerOptionOverrides(tree: Tree, compilerOptions: Record<keyof CompilerOptions, any>, tsConfigPath: string): Record<keyof CompilerOptions, any>;

package/src/utils/typescript/configuration.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNeededCompilerOptionOverrides = getNeededCompilerOptionOverrides;
+const path_1 = require("path");
+const ensure_typescript_1 = require("./ensure-typescript");
+const optionEnumTypeMap = {
+    importsNotUsedAsValues: 'ImportsNotUsedAsValues',
+    jsx: 'JsxEmit',
+    module: 'ModuleKind',
+    moduleDetection: 'ModuleDetectionKind',
+    moduleResolution: 'ModuleResolutionKind',
+    newLine: 'NewLineKind',
+    target: 'ScriptTarget',
+};
+let ts;
+/**
+ * Cleans up the provided compiler options to only include the options that are
+ * different or not set in the provided tsconfig file.
+ */
+function getNeededCompilerOptionOverrides(tree, compilerOptions, tsConfigPath) {
+    if (!ts) {
+        ts = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const tsSysFromTree = {
+        ...ts.sys,
+        readFile: (path) => tree.read(path, 'utf-8'),
+    };
+    const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(tsConfigPath, tsSysFromTree.readFile).config, tsSysFromTree, (0, path_1.dirname)(tsConfigPath));
+    // ModuleKind: { CommonJS: 'commonjs', ... } => ModuleKind: { commonjs: 'CommonJS', ... }
+    const reversedCompilerOptionsEnumValues = {
+        JsxEmit: reverseEnum(ts.server.protocol.JsxEmit),
+        ModuleKind: reverseEnum(ts.server.protocol.ModuleKind),
+        ModuleResolutionKind: reverseEnum(ts.server.protocol.ModuleResolutionKind),
+        NewLineKind: reverseEnum(ts.server.protocol.NewLineKind),
+        ScriptTarget: reverseEnum(ts.server.protocol.ScriptTarget),
+    };
+    const matchesValue = (key) => {
+        return (parsed.options[key] ===
+            ts[optionEnumTypeMap[key]][compilerOptions[key]] ||
+            parsed.options[key] ===
+                ts[optionEnumTypeMap[key]][reversedCompilerOptionsEnumValues[optionEnumTypeMap[key]][compilerOptions[key]]]);
+    };
+    let result = {};
+    for (const key of Object.keys(compilerOptions)) {
+        if (optionEnumTypeMap[key]) {
+            if (parsed.options[key] === undefined) {
+                result[key] = compilerOptions[key];
+            }
+            else if (!matchesValue(key)) {
+                result[key] = compilerOptions[key];
+            }
+        }
+        else if (parsed.options[key] !== compilerOptions[key]) {
+            result[key] = compilerOptions[key];
+        }
+    }
+    return result;
+}
+function reverseEnum(enumObj) {
+    return Object.keys(enumObj).reduce((acc, key) => {
+        acc[enumObj[key]] = key;
+        return acc;
+    }, {});
+}

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

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export declare function isUsingTypeScriptPlugin(tree: Tree): boolean;
+export declare function isUsingTsSolutionSetup(tree: Tree): boolean;

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUsingTypeScriptPlugin = isUsingTypeScriptPlugin;
+exports.isUsingTsSolutionSetup = isUsingTsSolutionSetup;
+const devkit_1 = require("@nx/devkit");
+const package_manager_workspaces_1 = require("../package-manager-workspaces");
+function isUsingTypeScriptPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    return (nxJson?.plugins?.some((p) => typeof p === 'string'
+        ? p === '@nx/js/typescript'
+        : p.plugin === '@nx/js/typescript') ?? false);
+}
+function isUsingTsSolutionSetup(tree) {
+    return ((0, package_manager_workspaces_1.isUsingPackageManagerWorkspaces)(tree) &&
+        isWorkspaceSetupWithTsSolution(tree));
+}
+function isWorkspaceSetupWithTsSolution(tree) {
+    if (!tree.exists('tsconfig.base.json') || !tree.exists('tsconfig.json')) {
+        return false;
+    }
+    const tsconfigJson = (0, devkit_1.readJson)(tree, 'tsconfig.json');
+    if (tsconfigJson.extends !== './tsconfig.base.json') {
+        return false;
+    }
+    /**
+     * New setup:
+     * - `files` is defined and set to an empty array
+     * - `references` is defined and set to an empty array
+     * - `include` is not defined or is set to an empty array
+     */
+    if (!tsconfigJson.files ||
+        tsconfigJson.files.length > 0 ||
+        !tsconfigJson.references ||
+        !!tsconfigJson.include?.length) {
+        return false;
+    }
+    const baseTsconfigJson = (0, devkit_1.readJson)(tree, 'tsconfig.base.json');
+    if (!baseTsconfigJson.compilerOptions ||
+        !baseTsconfigJson.compilerOptions.composite ||
+        !baseTsconfigJson.compilerOptions.declaration) {
+        return false;
+    }
+    const { compilerOptions, ...rest } = baseTsconfigJson;
+    if (Object.keys(rest).length > 0) {
+        return false;
+    }
+    return true;
+}