@nx/node 0.0.0-pr-31222-862e973 → 0.0.0-pr-31313-387cdca

package/src/generators/e2e-project/e2e-project.js

@@ -11,10 +11,13 @@ const versions_1 = require("../../utils/versions");
 const eslint_file_1 = require("@nx/eslint/src/generators/utils/eslint-file");
 const log_show_project_command_1 = require("@nx/devkit/src/utils/log-show-project-command");
 const config_file_1 = require("@nx/jest/src/utils/config/config-file");
+const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const posix_1 = require("node:path/posix");
+const add_swc_config_1 = require("@nx/js/src/utils/swc/add-swc-config");
 async function e2eProjectGenerator(host, options) {
     return await e2eProjectGeneratorInternal(host, {
         addPlugin: false,
-        projectNameAndRootFormat: 'derived',
+        useProjectJson: true,
         ...options,
     });
 }
@@ -23,22 +26,51 @@ async function e2eProjectGeneratorInternal(host, _options) {
     const options = await normalizeOptions(host, _options);
     const appProject = (0, devkit_1.readProjectConfiguration)(host, options.project);
     // TODO(@ndcunningham): This is broken.. the outputs are wrong.. and this isn't using the jest generator
-    (0, devkit_1.addProjectConfiguration)(host, options.e2eProjectName, {
-        root: options.e2eProjectRoot,
-        implicitDependencies: [options.project],
-        projectType: 'application',
-        targets: {
-            e2e: {
-                executor: '@nx/jest:jest',
-                outputs: ['{workspaceRoot}/coverage/{e2eProjectRoot}'],
-                options: {
-                    jestConfig: `${options.e2eProjectRoot}/jest.config.ts`,
-                    passWithNoTests: true,
+    const packageJson = {
+        name: options.importPath,
+        version: '0.0.1',
+        private: true,
+    };
+    if (!options.useProjectJson) {
+        packageJson.nx = {
+            name: options.e2eProjectName !== options.importPath
+                ? options.e2eProjectName
+                : undefined,
+            implicitDependencies: [options.project],
+            targets: {
+                e2e: {
+                    executor: '@nx/jest:jest',
+                    outputs: ['{projectRoot}/test-output/jest/coverage'],
+                    options: {
+                        jestConfig: `${options.e2eProjectRoot}/jest.config.ts`,
+                        passWithNoTests: true,
+                    },
+                    dependsOn: [`${options.project}:build`, `${options.project}:serve`],
                 },
-                dependsOn: [`${options.project}:build`],
             },
-        },
-    });
+        };
+    }
+    else {
+        (0, devkit_1.addProjectConfiguration)(host, options.e2eProjectName, {
+            root: options.e2eProjectRoot,
+            implicitDependencies: [options.project],
+            projectType: 'application',
+            targets: {
+                e2e: {
+                    executor: '@nx/jest:jest',
+                    outputs: ['{workspaceRoot}/coverage/{e2eProjectRoot}'],
+                    options: {
+                        jestConfig: `${options.e2eProjectRoot}/jest.config.ts`,
+                        passWithNoTests: true,
+                    },
+                    dependsOn: [`${options.project}:build`, `${options.project}:serve`],
+                },
+            },
+        });
+    }
+    if (!options.useProjectJson || options.isUsingTsSolutionConfig) {
+        (0, devkit_1.writeJson)(host, (0, devkit_1.joinPathFragments)(options.e2eProjectRoot, 'package.json'), packageJson);
+    }
     // TODO(@nicholas): Find a better way to get build target
     // We remove the 'test' target from the e2e project because it is not needed
     // The 'e2e' target is the one that should run the tests for the e2e project
@@ -65,19 +97,30 @@ async function e2eProjectGeneratorInternal(host, _options) {
         });
     }
     const jestPreset = (0, config_file_1.findRootJestPreset)(host) ?? 'jest.preset.js';
+    const tsConfigFile = options.isUsingTsSolutionConfig
+        ? 'tsconfig.json'
+        : 'tsconfig.spec.json';
+    const rootOffset = (0, devkit_1.offsetFromRoot)(options.e2eProjectRoot);
+    const coverageDirectory = options.isUsingTsSolutionConfig
+        ? 'test-output/jest/coverage'
+        : (0, devkit_1.joinPathFragments)(rootOffset, 'coverage', options.e2eProjectName);
+    const projectSimpleName = options.project.split('/').pop();
     if (options.projectType === 'server') {
         (0, devkit_1.generateFiles)(host, path.join(__dirname, 'files/server/common'), options.e2eProjectRoot, {
             ...options,
-            ...(0, devkit_1.names)(options.rootProject ? 'server' : options.project),
-            offsetFromRoot: (0, devkit_1.offsetFromRoot)(options.e2eProjectRoot),
+            ...(0, devkit_1.names)(options.rootProject ? 'server' : projectSimpleName),
+            tsConfigFile,
+            offsetFromRoot: rootOffset,
             jestPreset,
+            coverageDirectory,
             tmpl: '',
         });
         if (options.isNest) {
             (0, devkit_1.generateFiles)(host, path.join(__dirname, 'files/server/nest'), options.e2eProjectRoot, {
                 ...options,
-                ...(0, devkit_1.names)(options.rootProject ? 'server' : options.project),
-                offsetFromRoot: (0, devkit_1.offsetFromRoot)(options.e2eProjectRoot),
+                ...(0, devkit_1.names)(options.rootProject ? 'server' : projectSimpleName),
+                tsConfigFile,
+                offsetFromRoot: rootOffset,
                 tmpl: '',
             });
         }
@@ -86,20 +129,38 @@ async function e2eProjectGeneratorInternal(host, _options) {
         const mainFile = appProject.targets.build?.options?.outputPath;
         (0, devkit_1.generateFiles)(host, path.join(__dirname, 'files/cli'), options.e2eProjectRoot, {
             ...options,
-            ...(0, devkit_1.names)(options.rootProject ? 'cli' : options.project),
+            ...(0, devkit_1.names)(options.rootProject ? 'cli' : projectSimpleName),
             mainFile,
-            offsetFromRoot: (0, devkit_1.offsetFromRoot)(options.e2eProjectRoot),
+            tsConfigFile,
+            offsetFromRoot: rootOffset,
             jestPreset,
+            coverageDirectory,
+            tmpl: '',
+        });
+    }
+    if (options.isUsingTsSolutionConfig) {
+        (0, add_swc_config_1.addSwcTestConfig)(host, options.e2eProjectRoot, 'es6');
+        (0, devkit_1.generateFiles)(host, path.join(__dirname, 'files/ts-solution'), options.e2eProjectRoot, {
+            ...options,
+            relativeProjectReferencePath: (0, posix_1.relative)(options.e2eProjectRoot, appProject.root),
+            offsetFromRoot: rootOffset,
+            tmpl: '',
+        });
+    }
+    else {
+        (0, devkit_1.generateFiles)(host, path.join(__dirname, 'files/non-ts-solution'), options.e2eProjectRoot, {
+            ...options,
+            offsetFromRoot: rootOffset,
             tmpl: '',
         });
     }
     // axios is more than likely used in the application code, so install it as a regular dependency.
     const installTask = (0, devkit_1.addDependenciesToPackageJson)(host, { axios: versions_1.axiosVersion }, {});
     tasks.push(installTask);
-    if (options.linter === eslint_1.Linter.EsLint) {
+    if (options.linter === 'eslint') {
         const linterTask = await (0, eslint_1.lintProjectGenerator)(host, {
             project: options.e2eProjectName,
-            linter: eslint_1.Linter.EsLint,
+            linter: 'eslint',
             skipFormat: true,
             tsConfigPaths: [
                 (0, devkit_1.joinPathFragments)(options.e2eProjectRoot, 'tsconfig.json'),
@@ -118,6 +179,21 @@ async function e2eProjectGeneratorInternal(host, _options) {
             ]);
         }
     }
+    if (options.isUsingTsSolutionConfig) {
+        (0, devkit_1.updateJson)(host, 'tsconfig.json', (json) => {
+            json.references ??= [];
+            const e2eRef = `./${options.e2eProjectRoot}`;
+            if (!json.references.find((ref) => ref.path === e2eRef)) {
+                json.references.push({ path: e2eRef });
+            }
+            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) {
+        await (0, ts_solution_setup_1.addProjectToTsSolutionWorkspace)(host, options.e2eProjectRoot);
+    }
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(host);
     }
@@ -127,26 +203,30 @@ async function e2eProjectGeneratorInternal(host, _options) {
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
 async function normalizeOptions(tree, options) {
-    const { projectName: e2eProjectName, projectRoot: e2eProjectRoot } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(tree, {
-        name: options.name ?? `${options.project}-e2e`,
-        projectType: 'library',
-        directory: options.rootProject ? 'e2e' : options.directory,
-        projectNameAndRootFormat: options.rootProject
-            ? 'as-provided'
-            : options.projectNameAndRootFormat,
-        // this is an internal generator, don't save defaults
-        callingGenerator: null,
+    let directory = options.rootProject ? 'e2e' : options.directory;
+    if (!directory) {
+        const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+        directory = `${projectConfig.root}-e2e`;
+    }
+    const { projectName: e2eProjectName, projectRoot: e2eProjectRoot, importPath, } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(tree, {
+        name: options.name,
+        projectType: 'application',
+        directory,
     });
     const nxJson = (0, devkit_1.readNxJson)(tree);
     const addPlugin = process.env.NX_ADD_PLUGINS !== 'false' &&
         nxJson.useInferencePlugins !== false;
+    const isUsingTsSolutionConfig = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree);
     return {
         addPlugin,
         ...options,
         e2eProjectRoot,
         e2eProjectName,
+        importPath,
         port: options.port ?? 3000,
         rootProject: !!options.rootProject,
+        isUsingTsSolutionConfig,
+        useProjectJson: options.useProjectJson ?? !isUsingTsSolutionConfig,
     };
 }
 exports.default = e2eProjectGenerator;

package/src/generators/e2e-project/files/cli/jest.config.ts__tmpl__

@@ -1,13 +1,26 @@
+<%_ if (isUsingTsSolutionConfig) { _%>
+/* eslint-disable */
+import { readFileSync } from 'fs';
+
+// Reading the SWC compilation config for the spec files
+const swcJestConfig = JSON.parse(
+  readFileSync(`${__dirname}/.spec.swcrc`, 'utf-8')
+);
+
+// Disable .swcrc look-up by SWC core because we're passing in swcJestConfig ourselves
+swcJestConfig.swcrc = false;
+
+<%_ } _%>
 export default {
   displayName: '<%= e2eProjectName %>',
   preset: '<%= offsetFromRoot %><%= jestPreset %>',
   setupFiles: ['<rootDir>/src/test-setup.ts'],
   testEnvironment: 'node',
   transform: {
-    '^.+\\.[tj]s$': ['ts-jest', {
-      tsconfig: '<rootDir>/tsconfig.spec.json',
-    }],
+    '^.+\\.[tj]s$': <% if (isUsingTsSolutionConfig) { %>['@swc/jest', swcJestConfig]<% } else { %>['ts-jest', {
+      tsconfig: '<rootDir>/<%= tsConfigFile %>',
+    }]<% } %>,
   },
   moduleFileExtensions: ['ts', 'js', 'html'],
-  coverageDirectory: '<%= offsetFromRoot %>coverage/<%= e2eProjectName %>',
+  coverageDirectory: '<%= coverageDirectory %>',
 };

package/src/generators/e2e-project/files/server/common/jest.config.ts__tmpl__

@@ -1,3 +1,16 @@
+<%_ if (isUsingTsSolutionConfig) { _%>
+/* eslint-disable */
+import { readFileSync } from 'fs';
+
+// Reading the SWC compilation config for the spec files
+const swcJestConfig = JSON.parse(
+  readFileSync(`${__dirname}/.spec.swcrc`, 'utf-8')
+);
+
+// Disable .swcrc look-up by SWC core because we're passing in swcJestConfig ourselves
+swcJestConfig.swcrc = false;
+
+<%_ } _%>
 export default {
   displayName: '<%= e2eProjectName %>',
   preset: '<%= offsetFromRoot %><%= jestPreset %>',
@@ -6,10 +19,10 @@ export default {
   setupFiles: ['<rootDir>/src/support/test-setup.ts'],
   testEnvironment: 'node',
   transform: {
-    '^.+\\.[tj]s$': ['ts-jest', {
-      tsconfig: '<rootDir>/tsconfig.spec.json',
-    }],
+    '^.+\\.[tj]s$': <% if (isUsingTsSolutionConfig) { %>['@swc/jest', swcJestConfig]<% } else { %>['ts-jest', {
+      tsconfig: '<rootDir>/<%= tsConfigFile %>',
+    }]<% } %>,
   },
   moduleFileExtensions: ['ts', 'js', 'html'],
-  coverageDirectory: '<%= offsetFromRoot %>coverage/<%= e2eProjectName %>',
+  coverageDirectory: '<%= coverageDirectory %>',
 };

package/src/generators/e2e-project/files/server/common/src/support/global-setup.ts__tmpl__

@@ -1,3 +1,5 @@
+import { waitForPortOpen } from '@nx/node/utils';
+
 /* eslint-disable */
 var __TEARDOWN_MESSAGE__: string;
 
@@ -5,6 +7,10 @@ module.exports = async function() {
   // Start services that that the app needs to run (e.g. database, docker-compose, etc.).
   console.log('\nSetting up...\n');
 
+  const host = process.env.HOST ?? 'localhost';
+  const port = process.env.PORT ? Number(process.env.PORT) : <%= port %>;
+  await waitForPortOpen(port, { host });
+
   // Hint: Use `globalThis` to pass variables to global teardown.
   globalThis.__TEARDOWN_MESSAGE__ = '\nTearing down...\n';
 };

package/src/generators/e2e-project/files/server/common/src/support/global-teardown.ts__tmpl__

@@ -1,7 +1,10 @@
+import { killPort } from '@nx/node/utils';
 /* eslint-disable */
 
 module.exports = async function() {
   // Put clean up logic here (e.g. stopping services, docker-compose, etc.).
   // Hint: `globalThis` is shared between setup and teardown.
+  const port = process.env.PORT ? Number(process.env.PORT) : <%= port %>;
+  await killPort(port);
   console.log(globalThis.__TEARDOWN_MESSAGE__);
 };

package/src/generators/e2e-project/files/server/common/src/support/test-setup.ts__tmpl__

@@ -1,5 +1,4 @@
 /* eslint-disable */
-
 import axios from 'axios';
 
 module.exports = async function() {

package/src/generators/e2e-project/files/ts-solution/tsconfig.json__tmpl__

@@ -0,0 +1,14 @@
+{
+  "extends": "<%= offsetFromRoot %>tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "out-tsc/<%= e2eProjectName %>",
+    "esModuleInterop": true,
+    "noUnusedLocals": false,
+    "noImplicitAny": false
+  },
+  "include": [
+    "jest.config.ts",
+    "src/**/*.ts"
+  ],
+  "references": []
+}

package/src/generators/e2e-project/schema.d.ts

@@ -1,10 +1,7 @@
-import type { ProjectNameAndRootFormat } from '@nx/devkit/src/generators/project-name-and-root-utils';
-
 export interface Schema {
   project: string;
   projectType: 'server' | 'cli';
   directory?: string;
-  projectNameAndRootFormat?: ProjectNameAndRootFormat;
   name?: string;
   port?: number;
   linter?: 'eslint' | 'none';
@@ -12,4 +9,5 @@ export interface Schema {
   isNest?: boolean;
   skipFormat?: boolean;
   addPlugin?: boolean;
+  useProjectJson?: boolean;
 }

package/src/generators/e2e-project/schema.json

@@ -18,11 +18,6 @@
       "type": "string",
       "x-priority": "important"
     },
-    "projectNameAndRootFormat": {
-      "description": "Whether to generate the project name and root directory as provided (`as-provided`) or generate them composing their values and taking the configured layout into account (`derived`).",
-      "type": "string",
-      "enum": ["as-provided", "derived"]
-    },
     "name": {
       "description": "The name of the e2e project. Defaults to the project name with '-e2e' suffix.",
       "type": "string"
@@ -64,6 +59,10 @@
       "default": false,
       "hidden": true,
       "x-priority": "internal"
+    },
+    "useProjectJson": {
+      "type": "boolean",
+      "description": "Use a `project.json` configuration file instead of inlining the Nx configuration in the `package.json` file."
     }
   },
   "required": ["project"]

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

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "rootDir": "src",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "outDir": "dist",
+    "tsBuildInfoFile": "dist/tsconfig.lib.tsbuildinfo",
+    "emitDeclarationOnly": false,
+    "types": ["node"]
+  },
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"],
+  "include": ["src/**/*.ts"]
+}

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

@@ -6,6 +6,7 @@ export interface NormalizedSchema extends Schema {
     projectRoot: string;
     parsedTags: string[];
     compiler: 'swc' | 'tsc';
+    isUsingTsSolutionConfig: boolean;
 }
 export declare function libraryGenerator(tree: Tree, schema: Schema): Promise<GeneratorCallback>;
 export declare function libraryGeneratorInternal(tree: Tree, schema: Schema): Promise<GeneratorCallback>;

package/src/generators/library/library.js

@@ -11,40 +11,63 @@ const path_1 = require("path");
 const versions_1 = require("../../utils/versions");
 const init_1 = require("../init/init");
 const target_defaults_utils_1 = require("@nx/devkit/src/generators/target-defaults-utils");
+const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const sort_fields_1 = require("@nx/js/src/utils/package-json/sort-fields");
 async function libraryGenerator(tree, schema) {
     return await libraryGeneratorInternal(tree, {
         addPlugin: false,
-        projectNameAndRootFormat: 'derived',
+        useProjectJson: true,
         ...schema,
     });
 }
 async function libraryGeneratorInternal(tree, schema) {
     const options = await normalizeOptions(tree, schema);
-    const tasks = [
-        await (0, init_1.initGenerator)(tree, {
-            ...options,
-            skipFormat: true,
-        }),
-    ];
+    // 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) {
+        await (0, ts_solution_setup_1.addProjectToTsSolutionWorkspace)(tree, options.projectRoot);
+    }
+    const tasks = [];
     if (options.publishable === true && !schema.importPath) {
         throw new Error(`For publishable libs you have to provide a proper "--importPath" which needs to be a valid npm package name (e.g. my-awesome-lib or @myorg/my-lib)`);
     }
-    const libraryInstall = await (0, js_1.libraryGenerator)(tree, {
-        ...options,
-        bundler: schema.buildable ? 'tsc' : 'none',
+    // Create `package.json` first because @nx/js:lib generator will update it.
+    if (!options.useProjectJson ||
+        options.isUsingTsSolutionConfig ||
+        options.publishable ||
+        options.buildable) {
+        (0, devkit_1.writeJson)(tree, (0, devkit_1.joinPathFragments)(options.projectRoot, 'package.json'), {
+            name: options.importPath,
+            version: '0.0.1',
+            private: true,
+        });
+    }
+    tasks.push(await (0, js_1.libraryGenerator)(tree, {
+        ...schema,
+        bundler: schema.buildable || schema.publishable ? 'tsc' : 'none',
         includeBabelRc: schema.babelJest,
-        importPath: options.importPath,
+        importPath: schema.importPath,
         testEnvironment: 'node',
         skipFormat: true,
-        setParserOptionsProject: options.setParserOptionsProject,
-    });
-    tasks.push(libraryInstall);
+        setParserOptionsProject: schema.setParserOptionsProject,
+        useProjectJson: options.useProjectJson,
+    }));
+    updatePackageJson(tree, options);
+    tasks.push(await (0, init_1.initGenerator)(tree, {
+        ...options,
+        skipFormat: true,
+    }));
     createFiles(tree, options);
     if (options.js) {
         (0, devkit_1.updateTsConfigsToJs)(tree, options);
     }
     updateProject(tree, options);
     tasks.push(ensureDependencies(tree));
+    // Always run install to link packages.
+    if (options.isUsingTsSolutionConfig) {
+        tasks.push(() => (0, devkit_1.installPackagesTask)(tree, true));
+    }
+    (0, sort_fields_1.sortPackageJsonFields)(tree, options.projectRoot);
     if (!schema.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }
@@ -52,41 +75,35 @@ async function libraryGeneratorInternal(tree, schema) {
 }
 exports.default = libraryGenerator;
 async function normalizeOptions(tree, options) {
-    const { projectName, names: projectNames, projectRoot, importPath, projectNameAndRootFormat, } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(tree, {
+    await (0, project_name_and_root_utils_1.ensureRootProjectName)(options, 'library');
+    const { projectName, names: projectNames, projectRoot, importPath, } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(tree, {
         name: options.name,
         projectType: 'library',
         directory: options.directory,
         importPath: options.importPath,
-        projectNameAndRootFormat: options.projectNameAndRootFormat,
-        callingGenerator: '@nx/node:library',
     });
-    options.projectNameAndRootFormat = projectNameAndRootFormat;
     const nxJson = (0, devkit_1.readNxJson)(tree);
     const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
         nxJson.useInferencePlugins !== false;
     options.addPlugin ??= addPluginDefault;
-    const fileName = getCaseAwareFileName({
-        fileName: options.simpleModuleName
-            ? projectNames.projectSimpleName
-            : projectNames.projectFileName,
-        pascalCaseFiles: options.pascalCaseFiles,
-    });
+    const fileName = (0, devkit_1.names)(options.simpleModuleName
+        ? projectNames.projectSimpleName
+        : projectNames.projectFileName).fileName;
     const parsedTags = options.tags
         ? options.tags.split(',').map((s) => s.trim())
         : [];
+    const isUsingTsSolutionConfig = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree);
     return {
         ...options,
         fileName,
-        projectName,
+        projectName: isUsingTsSolutionConfig && !options.name ? importPath : projectName,
         projectRoot,
         parsedTags,
         importPath,
+        isUsingTsSolutionConfig,
+        useProjectJson: options.useProjectJson ?? !isUsingTsSolutionConfig,
     };
 }
-function getCaseAwareFileName(options) {
-    const normalized = (0, devkit_1.names)(options.fileName);
-    return options.pascalCaseFiles ? normalized.className : normalized.fileName;
-}
 function createFiles(tree, options) {
     const { className, name, propertyName } = (0, devkit_1.names)(options.fileName);
     (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, './files/lib'), options.projectRoot, {
@@ -100,9 +117,6 @@ function createFiles(tree, options) {
     if (options.unitTestRunner === 'none') {
         tree.delete((0, path_1.join)(options.projectRoot, `./src/lib/${options.fileName}.spec.ts`));
     }
-    if (!options.publishable && !options.buildable) {
-        tree.delete((0, path_1.join)(options.projectRoot, 'package.json'));
-    }
     if (options.js) {
         (0, devkit_1.toJS)(tree);
     }
@@ -115,17 +129,25 @@ function updateProject(tree, options) {
     const rootProject = options.projectRoot === '.' || options.projectRoot === '';
     project.targets = project.targets || {};
     (0, target_defaults_utils_1.addBuildTargetDefaults)(tree, `@nx/js:${options.compiler}`);
-    project.targets.build = {
-        executor: `@nx/js:${options.compiler}`,
-        outputs: ['{options.outputPath}'],
-        options: {
-            outputPath: (0, devkit_1.joinPathFragments)('dist', rootProject ? options.projectName : options.projectRoot),
-            tsConfig: `${options.projectRoot}/tsconfig.lib.json`,
-            packageJson: `${options.projectRoot}/package.json`,
-            main: `${options.projectRoot}/src/index` + (options.js ? '.js' : '.ts'),
-            assets: [`${options.projectRoot}/*.md`],
-        },
-    };
+    // For TS solution, we want tsc build to be inferred by `@nx/js/typescript` plugin.
+    if (!options.isUsingTsSolutionConfig || options.compiler === 'swc') {
+        project.targets.build = {
+            executor: `@nx/js:${options.compiler}`,
+            outputs: ['{options.outputPath}'],
+            options: {
+                outputPath: options.isUsingTsSolutionConfig
+                    ? (0, devkit_1.joinPathFragments)(options.projectRoot, 'dist')
+                    : (0, devkit_1.joinPathFragments)('dist', rootProject ? options.projectName : options.projectRoot),
+                tsConfig: `${options.projectRoot}/tsconfig.lib.json`,
+                packageJson: `${options.projectRoot}/package.json`,
+                main: `${options.projectRoot}/src/index` + (options.js ? '.js' : '.ts'),
+                assets: options.isUsingTsSolutionConfig
+                    ? undefined
+                    : [`${options.projectRoot}/*.md`],
+                stripLeadingPaths: options.isUsingTsSolutionConfig ? true : undefined,
+            },
+        };
+    }
     if (options.compiler === 'swc') {
         (0, add_swc_dependencies_1.addSwcDependencies)(tree);
         (0, add_swc_config_1.addSwcConfig)(tree, options.projectRoot);
@@ -138,3 +160,16 @@ function updateProject(tree, options) {
 function ensureDependencies(tree) {
     return (0, devkit_1.addDependenciesToPackageJson)(tree, { tslib: versions_1.tslibVersion }, { '@types/node': versions_1.typesNodeVersion });
 }
+function updatePackageJson(tree, options) {
+    const packageJsonPath = (0, devkit_1.joinPathFragments)(options.projectRoot, 'package.json');
+    if (!tree.exists(packageJsonPath)) {
+        return;
+    }
+    const packageJson = (0, devkit_1.readJson)(tree, packageJsonPath);
+    if (packageJson.type === 'module') {
+        // The @nx/js:lib generator can set the type to 'module' which would
+        // potentially break consumers of the library.
+        delete packageJson.type;
+    }
+    (0, devkit_1.writeJson)(tree, packageJsonPath, packageJson);
+}

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

@@ -1,10 +1,8 @@
-import type { ProjectNameAndRootFormat } from '@nx/devkit/src/generators/project-name-and-root-utils';
 import type { Linter, LinterType } from '@nx/eslint';
 
 export interface Schema {
-  name: string;
-  directory?: string;
-  projectNameAndRootFormat?: ProjectNameAndRootFormat;
+  directory: string;
+  name?: string;
   simpleModuleName?: boolean;
   skipTsConfig?: boolean;
   skipFormat?: boolean;
@@ -18,10 +16,10 @@ export interface Schema {
   rootDir?: string;
   babelJest?: boolean;
   js?: boolean;
-  pascalCaseFiles?: boolean;
   strict?: boolean;
   standaloneConfig?: boolean;
   setParserOptionsProject?: boolean;
   compiler: 'tsc' | 'swc';
   addPlugin?: boolean;
+  useProjectJson?: boolean;
 }