@nx/js 20.4.0-beta.0 → 20.4.0-beta.2

package/migrations.json

@@ -124,6 +124,19 @@
           "alwaysAddToPackageJson": false
         }
       }
+    },
+    "20.4.0": {
+      "version": "20.4.0-beta.1",
+      "x-prompt": "Do you want to update to TypeScript v5.7?",
+      "requires": {
+        "typescript": ">=5.6.0 <5.7.0"
+      },
+      "packages": {
+        "typescript": {
+          "version": "~5.7.2",
+          "alwaysAddToPackageJson": false
+        }
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "20.4.0-beta.0",
+  "version": "20.4.0-beta.2",
   "private": false,
   "description": "The JS plugin for Nx contains executors and generators that provide the best experience for developing JavaScript and TypeScript projects. ",
   "repository": {
@@ -39,8 +39,8 @@
     "@babel/preset-env": "^7.23.2",
     "@babel/preset-typescript": "^7.22.5",
     "@babel/runtime": "^7.22.6",
-    "@nx/devkit": "20.4.0-beta.0",
-    "@nx/workspace": "20.4.0-beta.0",
+    "@nx/devkit": "20.4.0-beta.2",
+    "@nx/workspace": "20.4.0-beta.2",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^2.8.0",

package/src/generators/init/files/ts-solution/tsconfig.base.json__tmpl__

@@ -5,9 +5,11 @@
     "emitDeclarationOnly": true,
     "importHelpers": true,
     "isolatedModules": true,
-    "lib": ["es2022"],
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
+    "lib": ["es2022"],<% if (platform === 'node') { %>
+    "module": "nodenext",
+    "moduleResolution": "nodenext",<% } else { %>
+    "module": "esnext",
+    "moduleResolution": "bundler",<% } %>
     "noEmitOnError": true,
     "noFallthroughCasesInSwitch": true,
     "noImplicitOverride": true,

package/src/generators/init/init.js

@@ -87,7 +87,9 @@ async function initGeneratorInternal(tree, schema) {
     }
     if (schema.addTsConfigBase && !(0, ts_config_1.getRootTsConfigFileName)(tree)) {
         if (schema.addTsPlugin) {
+            const platform = schema.platform ?? 'node';
             (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, './files/ts-solution'), '.', {
+                platform,
                 tmpl: '',
             });
         }

package/src/generators/init/schema.d.ts

@@ -9,4 +9,5 @@ export interface InitSchema {
   addPlugin?: boolean;
   updatePackageScripts?: boolean;
   addTsPlugin?: boolean;
+  platform?: 'web' | 'node';
 }

package/src/generators/library/files/tsconfig-lib/ts-solution/tsconfig.lib.json__tmpl__

@@ -5,7 +5,7 @@
     "rootDir": "src",
     "outDir": "dist",
     "tsBuildInfoFile": "dist/tsconfig.lib.tsbuildinfo",
-    "emitDeclarationOnly": false,<% if (compilerOptions.length) { %>
+    "emitDeclarationOnly": <%= emitDeclarationOnly %>,<% if (compilerOptions.length) { %>
     <%- compilerOptions %>,<% } %>
     "types": ["node"]
   },

package/src/generators/library/library.js

@@ -23,6 +23,8 @@ const ts_solution_setup_1 = require("../../utils/typescript/ts-solution-setup");
 const versions_1 = require("../../utils/versions");
 const init_1 = require("../init/init");
 const generator_1 = require("../setup-verdaccio/generator");
+const sort_fields_1 = require("../../utils/package-json/sort-fields");
+const get_import_path_1 = require("../../utils/get-import-path");
 const defaultOutputDirectory = 'dist';
 async function libraryGenerator(tree, schema) {
     return await libraryGeneratorInternal(tree, {
@@ -42,6 +44,11 @@ async function libraryGeneratorInternal(tree, schema) {
         formatter: (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree) ? 'none' : 'prettier',
     }));
     const options = await normalizeOptions(tree, schema);
+    // If we are using the new TS solution
+    // We need to update the workspace file (package.json or pnpm-workspaces.yaml) to include the new project
+    if (options.isUsingTsSolutionConfig) {
+        (0, ts_solution_setup_1.addProjectToTsSolutionWorkspace)(tree, options.projectRoot);
+    }
     createFiles(tree, options);
     await configureProject(tree, options);
     if (!options.skipPackageJson) {
@@ -85,7 +92,8 @@ async function libraryGeneratorInternal(tree, schema) {
     if (options.unitTestRunner === 'jest') {
         const jestCallback = await addJest(tree, options);
         tasks.push(jestCallback);
-        if (options.bundler === 'swc' || options.bundler === 'rollup') {
+        if (!options.isUsingTsSolutionConfig &&
+            (options.bundler === 'swc' || options.bundler === 'rollup')) {
             replaceJestConfig(tree, options);
         }
     }
@@ -121,18 +129,23 @@ async function libraryGeneratorInternal(tree, schema) {
             // add project reference to the runtime tsconfig.lib.json file
             json.references ??= [];
             json.references.push({ path: './tsconfig.lib.json' });
-            if (options.isUsingTsSolutionConfig && options.bundler === 'rollup') {
-                json.compilerOptions.module = 'esnext';
-                json.compilerOptions.moduleResolution = 'bundler';
+            const compilerOptions = getCompilerOptions(options);
+            // respect the module and moduleResolution set by the test runner generator
+            if (json.compilerOptions.module) {
+                compilerOptions.module = json.compilerOptions.module;
+            }
+            if (json.compilerOptions.moduleResolution) {
+                compilerOptions.moduleResolution =
+                    json.compilerOptions.moduleResolution;
             }
+            // filter out options already set with the same value in root tsconfig file that we're going to extend from
+            json.compilerOptions = (0, configuration_1.getNeededCompilerOptionOverrides)(tree, { ...json.compilerOptions, ...compilerOptions }, 
+            // must have been created by now
+            (0, ts_config_1.getRootTsConfigFileName)(tree));
             return json;
         });
     }
-    // If we are using the new TS solution
-    // We need to update the workspace file (package.json or pnpm-workspaces.yaml) to include the new project
-    if (options.isUsingTsSolutionConfig) {
-        (0, ts_solution_setup_1.addProjectToTsSolutionWorkspace)(tree, options.projectRoot);
-    }
+    (0, sort_fields_1.sortPackageJsonFields)(tree, options.projectRoot);
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }
@@ -232,8 +245,19 @@ async function configureProject(tree, options) {
         if (!projectConfiguration.tags?.length) {
             delete projectConfiguration.tags;
         }
+        // We want a minimal setup, so unless targets and tags are set, just skip the `nx` property in `package.json`.
+        if (options.isUsingTsSolutionConfig) {
+            delete projectConfiguration.projectType;
+            // SWC executor has logic around sourceRoot and `--strip-leading-paths`. If it is not set then dist will contain the `src` folder rather than being flat.
+            // TODO(leo): Look at how we can remove the dependency on sourceRoot for SWC.
+            if (options.bundler !== 'swc') {
+                delete projectConfiguration.sourceRoot;
+            }
+        }
         // empty targets are cleaned up automatically by `updateProjectConfiguration`
-        (0, devkit_1.updateProjectConfiguration)(tree, options.name, projectConfiguration);
+        (0, devkit_1.updateProjectConfiguration)(tree, options.isUsingTsSolutionConfig
+            ? options.importPath ?? options.name
+            : options.name, projectConfiguration);
     }
     else if (options.config === 'workspace' || options.config === 'project') {
         (0, devkit_1.addProjectConfiguration)(tree, options.name, projectConfiguration);
@@ -305,19 +329,21 @@ async function addLint(tree, options) {
                 ruleSeverity = value;
                 ruleOptions = {};
             }
-            if (options.bundler === 'vite' || options.unitTestRunner === 'vitest') {
-                ruleOptions.ignoredFiles ??= [];
-                ruleOptions.ignoredFiles.push('{projectRoot}/vite.config.{js,ts,mjs,mts}');
-                o.rules['@nx/dependency-checks'] = [ruleSeverity, ruleOptions];
+            const ignoredFiles = new Set(ruleOptions.ignoredFiles ?? []);
+            if (options.bundler === 'vite') {
+                ignoredFiles.add('{projectRoot}/vite.config.{js,ts,mjs,mts}');
             }
             else if (options.bundler === 'rollup') {
-                ruleOptions.ignoredFiles ??= [];
-                ruleOptions.ignoredFiles.push('{projectRoot}/rollup.config.{js,ts,mjs,mts,cjs,cts}');
-                o.rules['@nx/dependency-checks'] = [ruleSeverity, ruleOptions];
+                ignoredFiles.add('{projectRoot}/rollup.config.{js,ts,mjs,mts,cjs,cts}');
             }
             else if (options.bundler === 'esbuild') {
-                ruleOptions.ignoredFiles ??= [];
-                ruleOptions.ignoredFiles.push('{projectRoot}/esbuild.config.{js,ts,mjs,mts}');
+                ignoredFiles.add('{projectRoot}/esbuild.config.{js,ts,mjs,mts}');
+            }
+            if (options.unitTestRunner === 'vitest') {
+                ignoredFiles.add('{projectRoot}/vite.config.{js,ts,mjs,mts}');
+            }
+            if (ignoredFiles.size) {
+                ruleOptions.ignoredFiles = Array.from(ignoredFiles);
                 o.rules['@nx/dependency-checks'] = [ruleSeverity, ruleOptions];
             }
             return o;
@@ -419,10 +445,8 @@ function createFiles(tree, options) {
                 },
                 ...determineEntryFields(options),
             };
-            if (options.bundler === 'none') {
-                updatedPackageJson.type = 'module';
-            }
-            else if (options.bundler !== 'vite' && options.bundler !== 'rollup') {
+            if (options.isUsingTsSolutionConfig &&
+                !['none', 'rollup', 'vite'].includes(options.bundler)) {
                 return (0, update_package_json_1.getUpdatedPackageJsonContent)(updatedPackageJson, {
                     main: (0, path_1.join)(options.projectRoot, 'src/index.ts'),
                     outputPath: (0, devkit_1.joinPathFragments)(options.projectRoot, 'dist'),
@@ -451,21 +475,17 @@ function createFiles(tree, options) {
             // https://docs.npmjs.com/cli/v10/configuring-npm/package-json#files
             packageJson.files = ['dist', '!**/*.tsbuildinfo'];
         }
-        if (options.isUsingTsSolutionConfig) {
-            if (options.bundler === 'none') {
-                packageJson.type = 'module';
-            }
-            else if (options.bundler !== 'vite' && options.bundler !== 'rollup') {
-                packageJson = (0, update_package_json_1.getUpdatedPackageJsonContent)(packageJson, {
-                    main: (0, path_1.join)(options.projectRoot, 'src/index.ts'),
-                    outputPath: (0, devkit_1.joinPathFragments)(options.projectRoot, 'dist'),
-                    projectRoot: options.projectRoot,
-                    rootDir: (0, path_1.join)(options.projectRoot, 'src'),
-                    generateExportsField: true,
-                    packageJsonPath,
-                    format: ['esm'],
-                });
-            }
+        if (options.isUsingTsSolutionConfig &&
+            !['none', 'rollup', 'vite'].includes(options.bundler)) {
+            packageJson = (0, update_package_json_1.getUpdatedPackageJsonContent)(packageJson, {
+                main: (0, path_1.join)(options.projectRoot, 'src/index.ts'),
+                outputPath: (0, devkit_1.joinPathFragments)(options.projectRoot, 'dist'),
+                projectRoot: options.projectRoot,
+                rootDir: (0, path_1.join)(options.projectRoot, 'src'),
+                generateExportsField: true,
+                packageJsonPath,
+                format: ['esm'],
+            });
         }
         (0, devkit_1.writeJson)(tree, packageJsonPath, packageJson);
     }
@@ -478,6 +498,12 @@ function createFiles(tree, options) {
             return json;
         });
     }
+    else if (!options.isUsingTsSolutionConfig &&
+        options.useProjectJson &&
+        (!options.bundler || options.bundler === 'none') &&
+        !(options.projectRoot === '.')) {
+        tree.delete(packageJsonPath);
+    }
     if (options.minimal && !(options.projectRoot === '.')) {
         tree.delete((0, path_1.join)(options.projectRoot, 'README.md'));
     }
@@ -490,12 +516,12 @@ async function addJest(tree, options) {
         setupFile: 'none',
         supportTsx: false,
         skipSerializers: true,
-        testEnvironment: options.testEnvironment,
+        testEnvironment: options.testEnvironment ?? 'node',
         skipFormat: true,
-        compiler: options.bundler === 'swc' || options.bundler === 'tsc'
-            ? options.bundler
-            : options.bundler === 'rollup'
-                ? 'swc'
+        compiler: options.shouldUseSwcJest
+            ? 'swc'
+            : options.bundler === 'tsc'
+                ? 'tsc'
                 : undefined,
         runtimeTsconfigFileName: 'tsconfig.lib.json',
     });
@@ -616,16 +642,22 @@ async function normalizeOptions(tree, options) {
     options.minimal ??= false;
     // We default to generate a project.json file if the new setup is not being used
     options.useProjectJson ??= !isUsingTsSolutionConfig;
+    const shouldUseSwcJest = options.bundler === 'swc' ||
+        options.bundler === 'rollup' ||
+        isUsingTsSolutionConfig;
     return {
         ...options,
         fileName,
-        name: projectName,
+        name: isUsingTsSolutionConfig
+            ? (0, get_import_path_1.getImportPath)(tree, projectName)
+            : projectName,
         projectNames,
         projectRoot,
         parsedTags,
         importPath,
         hasPlugin,
         isUsingTsSolutionConfig,
+        shouldUseSwcJest,
     };
 }
 function addProjectDependencies(tree, options) {
@@ -690,33 +722,8 @@ function getOutputPath(options) {
 }
 function createProjectTsConfigs(tree, options) {
     const rootOffset = (0, devkit_1.offsetFromRoot)(options.projectRoot);
-    let compilerOptionOverrides = {
-        module: options.isUsingTsSolutionConfig
-            ? options.bundler === 'rollup'
-                ? 'esnext'
-                : 'nodenext'
-            : 'commonjs',
-        ...(options.isUsingTsSolutionConfig
-            ? options.bundler === 'rollup'
-                ? { moduleResolution: 'bundler' }
-                : { moduleResolution: 'nodenext' }
-            : {}),
-        ...(options.js ? { allowJs: true } : {}),
-        ...(options.strict
-            ? {
-                forceConsistentCasingInFileNames: true,
-                strict: true,
-                importHelpers: true,
-                noImplicitOverride: true,
-                noImplicitReturns: true,
-                noFallthroughCasesInSwitch: true,
-                ...(!options.isUsingTsSolutionConfig
-                    ? { noPropertyAccessFromIndexSignature: true }
-                    : {}),
-            }
-            : {}),
-    };
-    if (!options.rootProject || options.isUsingTsSolutionConfig) {
+    let compilerOptionOverrides = getCompilerOptions(options);
+    if (options.isUsingTsSolutionConfig) {
         // filter out options already set with the same value in root tsconfig file that we're going to extend from
         compilerOptionOverrides = (0, configuration_1.getNeededCompilerOptionOverrides)(tree, compilerOptionOverrides, 
         // must have been created by now
@@ -734,6 +741,7 @@ function createProjectTsConfigs(tree, options) {
         outDir: options.bundler === 'tsc'
             ? 'dist'
             : `out-tsc/${options.projectRoot.split('/').pop()}`,
+        emitDeclarationOnly: options.bundler === 'tsc' ? false : true,
     });
     // tsconfig.json
     if (options.isUsingTsSolutionConfig) {
@@ -788,6 +796,34 @@ function createProjectTsConfigs(tree, options) {
     };
     (0, devkit_1.writeJson)(tree, (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.json'), tsconfig);
 }
+function getCompilerOptions(options) {
+    return {
+        module: options.isUsingTsSolutionConfig
+            ? options.bundler === 'rollup'
+                ? 'esnext'
+                : 'nodenext'
+            : 'commonjs',
+        ...(options.isUsingTsSolutionConfig
+            ? {
+                moduleResolution: options.bundler === 'rollup' ? 'bundler' : 'nodenext',
+            }
+            : {}),
+        ...(options.js ? { allowJs: true } : {}),
+        ...(options.strict
+            ? {
+                forceConsistentCasingInFileNames: true,
+                strict: true,
+                importHelpers: true,
+                noImplicitOverride: true,
+                noImplicitReturns: true,
+                noFallthroughCasesInSwitch: true,
+                ...(!options.isUsingTsSolutionConfig
+                    ? { noPropertyAccessFromIndexSignature: true }
+                    : {}),
+            }
+            : {}),
+    };
+}
 function determineDependencies(options) {
     switch (options.bundler) {
         case 'tsc':
@@ -867,6 +903,7 @@ function determineEntryFields(options) {
         case 'none': {
             if (options.isUsingTsSolutionConfig) {
                 return {
+                    type: 'module',
                     main: options.js ? './src/index.js' : './src/index.ts',
                     types: options.js ? './src/index.js' : './src/index.ts',
                     exports: {

package/src/generators/library/schema.d.ts

@@ -46,4 +46,5 @@ export interface NormalizedLibraryGeneratorOptions
   importPath?: string;
   hasPlugin: boolean;
   isUsingTsSolutionConfig: boolean;
+  shouldUseSwcJest: boolean;
 }

package/src/utils/package-json/sort-fields.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function sortPackageJsonFields(tree: Tree, projectRoot: string): void;

package/src/utils/package-json/sort-fields.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortPackageJsonFields = sortPackageJsonFields;
+const devkit_1 = require("@nx/devkit");
+function sortPackageJsonFields(tree, projectRoot) {
+    const packageJsonPath = (0, devkit_1.joinPathFragments)(projectRoot, 'package.json');
+    if (!tree.exists(packageJsonPath))
+        return;
+    (0, devkit_1.updateJson)(tree, packageJsonPath, (json) => {
+        // Note that these are fields that our generators may use, so it's not exhaustive.
+        const orderedTopFields = new Set([
+            'name',
+            'version',
+            'private',
+            'description',
+            'type',
+            'main',
+            'module',
+            'types',
+            'exports',
+        ]);
+        const orderedBottomFields = new Set([
+            'dependencies',
+            'devDependencies',
+            'peerDependencies',
+            'optionalDependencies',
+        ]);
+        const otherFields = new Set(Object.keys(json).filter((k) => !orderedTopFields.has(k) && !orderedBottomFields.has(k)));
+        const allFields = [
+            ...orderedTopFields,
+            ...otherFields,
+            ...orderedBottomFields,
+        ];
+        const sortedJson = {};
+        for (const k of allFields) {
+            sortedJson[k] = json[k];
+        }
+        return sortedJson;
+    });
+}

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

@@ -1,3 +1,4 @@
 import { type Tree } from '@nx/devkit';
 export declare const defaultExclude: string[];
-export declare function addSwcConfig(tree: Tree, projectDir: string, type?: 'commonjs' | 'es6'): void;
+export declare function addSwcConfig(tree: Tree, projectDir: string, type?: 'commonjs' | 'es6', supportTsx?: boolean): void;
+export declare function addSwcTestConfig(tree: Tree, projectDir: string, type?: 'commonjs' | 'es6', supportTsx?: boolean): void;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultExclude = void 0;
 exports.addSwcConfig = addSwcConfig;
+exports.addSwcTestConfig = addSwcTestConfig;
 const path_1 = require("path");
 exports.defaultExclude = [
     'jest.config.ts',
@@ -11,17 +12,25 @@ exports.defaultExclude = [
     './**/jest-setup.ts$',
     '.*.js$',
 ];
-const swcOptionsString = (type = 'commonjs') => `{
+const swcOptionsString = (type = 'commonjs', exclude, supportTsx) => `{
   "jsc": {
     "target": "es2017",
     "parser": {
       "syntax": "typescript",
       "decorators": true,
-      "dynamicImport": true
+      "dynamicImport": true${supportTsx
+    ? `,
+      "tsx": true`
+    : ''}
     },
     "transform": {
       "decoratorMetadata": true,
-      "legacyDecorator": true
+      "legacyDecorator": true${supportTsx
+    ? `,
+      "react": {
+        "runtime": "automatic"
+      }`
+    : ''}
     },
     "keepClassNames": true,
     "externalHelpers": true,
@@ -31,11 +40,18 @@ const swcOptionsString = (type = 'commonjs') => `{
     "type": "${type}"
   },
   "sourceMaps": true,
-  "exclude": ${JSON.stringify(exports.defaultExclude)}
-}`;
-function addSwcConfig(tree, projectDir, type = 'commonjs') {
+  "exclude": ${JSON.stringify(exclude)}
+}
+`;
+function addSwcConfig(tree, projectDir, type = 'commonjs', supportTsx = false) {
     const swcrcPath = (0, path_1.join)(projectDir, '.swcrc');
     if (tree.exists(swcrcPath))
         return;
-    tree.write(swcrcPath, swcOptionsString(type));
+    tree.write(swcrcPath, swcOptionsString(type, exports.defaultExclude, supportTsx));
+}
+function addSwcTestConfig(tree, projectDir, type = 'commonjs', supportTsx = false) {
+    const swcrcPath = (0, path_1.join)(projectDir, '.spec.swcrc');
+    if (tree.exists(swcrcPath))
+        return;
+    tree.write(swcrcPath, swcOptionsString(type, [], supportTsx));
 }

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

@@ -5,3 +5,4 @@ export declare function assertNotUsingTsSolutionSetup(tree: Tree, pluginName: st
 export declare function findRuntimeTsConfigName(tree: Tree, projectRoot: string): string | null;
 export declare function updateTsconfigFiles(tree: Tree, projectRoot: string, runtimeTsconfigFileName: string, compilerOptions: Record<string, string | boolean | string[]>, exclude?: string[], rootDir?: string): void;
 export declare function addProjectToTsSolutionWorkspace(tree: Tree, projectDir: string): void;
+export declare function getProjectType(tree: Tree, projectRoot: string, projectType?: 'library' | 'application'): 'library' | 'application';

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

@@ -6,10 +6,12 @@ exports.assertNotUsingTsSolutionSetup = assertNotUsingTsSolutionSetup;
 exports.findRuntimeTsConfigName = findRuntimeTsConfigName;
 exports.updateTsconfigFiles = updateTsconfigFiles;
 exports.addProjectToTsSolutionWorkspace = addProjectToTsSolutionWorkspace;
+exports.getProjectType = getProjectType;
 const devkit_1 = require("@nx/devkit");
 const posix_1 = require("node:path/posix");
 const tree_1 = require("nx/src/generators/tree");
 const package_manager_workspaces_1 = require("../package-manager-workspaces");
+const configuration_1 = require("./configuration");
 function isUsingTypeScriptPlugin(tree) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
     return (nxJson?.plugins?.some((p) => typeof p === 'string'
@@ -77,15 +79,14 @@ function findRuntimeTsConfigName(tree, projectRoot) {
     return null;
 }
 function updateTsconfigFiles(tree, projectRoot, runtimeTsconfigFileName, compilerOptions, exclude = [], rootDir = 'src') {
-    if (!isUsingTsSolutionSetup(tree))
+    if (!isUsingTsSolutionSetup(tree)) {
         return;
+    }
     const offset = (0, devkit_1.offsetFromRoot)(projectRoot);
-    const tsconfig = `${projectRoot}/${runtimeTsconfigFileName}`;
-    const tsconfigSpec = `${projectRoot}/tsconfig.spec.json`;
-    const e2eRoot = `${projectRoot}-e2e`;
-    const tsconfigE2E = `${e2eRoot}/tsconfig.json`;
-    if (tree.exists(tsconfig)) {
-        (0, devkit_1.updateJson)(tree, tsconfig, (json) => {
+    const runtimeTsconfigPath = `${projectRoot}/${runtimeTsconfigFileName}`;
+    const specTsconfigPath = `${projectRoot}/tsconfig.spec.json`;
+    if (tree.exists(runtimeTsconfigPath)) {
+        (0, devkit_1.updateJson)(tree, runtimeTsconfigPath, (json) => {
             json.extends = (0, devkit_1.joinPathFragments)(offset, 'tsconfig.base.json');
             json.compilerOptions = {
                 ...json.compilerOptions,
@@ -100,13 +101,15 @@ function updateTsconfigFiles(tree, projectRoot, runtimeTsconfigFileName, compile
                 // at `<outDir>/<relative path to config from rootDir>/`, so we need
                 // to set it explicitly to ensure it's output to the outDir
                 // https://www.typescriptlang.org/tsconfig/#tsBuildInfoFile
-                json.compilerOptions.tsBuildInfoFile = (0, posix_1.join)('out-tsc', projectRoot.split('/').at(-1), (0, posix_1.basename)(runtimeTsconfigFileName, '.json') + '.tsbuildinfo');
+                json.compilerOptions.tsBuildInfoFile = (0, posix_1.join)(json.compilerOptions.outDir, (0, posix_1.basename)(runtimeTsconfigFileName, '.json') + '.tsbuildinfo');
             }
             else if (json.compilerOptions.tsBuildInfoFile) {
                 // when rootDir is '.' or not set, it would be output to the outDir, so
                 // we don't need to set it explicitly
                 delete json.compilerOptions.tsBuildInfoFile;
             }
+            // don't duplicate compiler options from base tsconfig
+            json.compilerOptions = (0, configuration_1.getNeededCompilerOptionOverrides)(tree, json.compilerOptions, 'tsconfig.base.json');
             const excludeSet = json.exclude
                 ? new Set(['out-tsc', 'dist', ...json.exclude, ...exclude])
                 : new Set(exclude);
@@ -114,17 +117,20 @@ function updateTsconfigFiles(tree, projectRoot, runtimeTsconfigFileName, compile
             return json;
         });
     }
-    if (tree.exists(tsconfigSpec)) {
-        (0, devkit_1.updateJson)(tree, tsconfigSpec, (json) => {
+    if (tree.exists(specTsconfigPath)) {
+        (0, devkit_1.updateJson)(tree, specTsconfigPath, (json) => {
             json.extends = (0, devkit_1.joinPathFragments)(offset, 'tsconfig.base.json');
             json.compilerOptions = {
                 ...json.compilerOptions,
                 ...compilerOptions,
             };
+            // don't duplicate compiler options from base tsconfig
+            json.compilerOptions = (0, configuration_1.getNeededCompilerOptionOverrides)(tree, json.compilerOptions, 'tsconfig.base.json');
             const runtimePath = `./${runtimeTsconfigFileName}`;
             json.references ??= [];
-            if (!json.references.some((x) => x.path === runtimePath))
+            if (!json.references.some((x) => x.path === runtimePath)) {
                 json.references.push({ path: runtimePath });
+            }
             return json;
         });
     }
@@ -132,8 +138,9 @@ function updateTsconfigFiles(tree, projectRoot, runtimeTsconfigFileName, compile
         (0, devkit_1.updateJson)(tree, 'tsconfig.json', (json) => {
             const projectPath = './' + projectRoot;
             json.references ??= [];
-            if (!json.references.some((x) => x.path === projectPath))
+            if (!json.references.some((x) => x.path === projectPath)) {
                 json.references.push({ path: projectPath });
+            }
             return json;
         });
     }
@@ -166,3 +173,19 @@ function addProjectToTsSolutionWorkspace(tree, projectDir) {
         }
     }
 }
+function getProjectType(tree, projectRoot, projectType) {
+    if (projectType)
+        return projectType;
+    if (tree.exists((0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.lib.json')))
+        return 'library';
+    if (tree.exists((0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.app.json')))
+        return 'application';
+    // If there are no exports, assume it is an application since both buildable and non-buildable libraries have exports.
+    const packageJsonPath = (0, devkit_1.joinPathFragments)(projectRoot, 'package.json');
+    const packageJson = tree.exists(packageJsonPath)
+        ? (0, devkit_1.readJson)(tree, (0, devkit_1.joinPathFragments)(projectRoot, 'package.json'))
+        : null;
+    if (!packageJson?.exports)
+        return 'application';
+    return 'library';
+}

package/src/utils/versions.d.ts

@@ -8,7 +8,7 @@ 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 typescriptVersion = "~5.6.2";
+export declare const typescriptVersion = "~5.7.2";
 /**
  * The minimum version is currently determined from the lowest version
  * that's supported by the lowest Angular supported version, e.g.

package/src/utils/versions.js

@@ -12,7 +12,7 @@ exports.tsLibVersion = '^2.3.0';
 exports.typesNodeVersion = '18.16.9';
 exports.verdaccioVersion = '^5.0.4';
 // Typescript
-exports.typescriptVersion = '~5.6.2';
+exports.typescriptVersion = '~5.7.2';
 /**
  * The minimum version is currently determined from the lowest version
  * that's supported by the lowest Angular supported version, e.g.