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

package/src/generators/library/library.js

@@ -7,19 +7,27 @@ const devkit_1 = require("@nx/devkit");
 const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
 const target_defaults_utils_1 = require("@nx/devkit/src/generators/target-defaults-utils");
 const log_show_project_command_1 = require("@nx/devkit/src/utils/log-show-project-command");
+const enquirer_1 = require("enquirer");
 const find_matching_projects_1 = require("nx/src/utils/find-matching-projects");
+const is_ci_1 = require("nx/src/utils/is-ci");
 const path_1 = require("path");
+const package_manager_workspaces_1 = require("../../utils/package-manager-workspaces");
 const add_swc_config_1 = require("../../utils/swc/add-swc-config");
 const add_swc_dependencies_1 = require("../../utils/swc/add-swc-dependencies");
+const configuration_1 = require("../../utils/typescript/configuration");
 const create_ts_config_1 = require("../../utils/typescript/create-ts-config");
 const ts_config_1 = require("../../utils/typescript/ts-config");
+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 package_manager_workspaces_2 = require("./utils/package-manager-workspaces");
+const plugin_registrations_1 = require("./utils/plugin-registrations");
 const defaultOutputDirectory = 'dist';
 async function libraryGenerator(tree, schema) {
     return await libraryGeneratorInternal(tree, {
         addPlugin: false,
+        useProjectJson: true,
         ...schema,
     });
 }
@@ -29,10 +37,13 @@ async function libraryGeneratorInternal(tree, schema) {
         ...schema,
         skipFormat: true,
         tsConfigName: schema.rootProject ? 'tsconfig.json' : 'tsconfig.base.json',
+        addTsConfigBase: true,
+        // In the new setup, Prettier is prompted for and installed during `create-nx-workspace`.
+        formatter: (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree) ? 'none' : 'prettier',
     }));
     const options = await normalizeOptions(tree, schema);
     createFiles(tree, options);
-    await addProject(tree, options);
+    await configureProject(tree, options);
     if (!options.skipPackageJson) {
         tasks.push(addProjectDependencies(tree, options));
     }
@@ -98,17 +109,32 @@ async function libraryGeneratorInternal(tree, schema) {
             testEnvironment: options.testEnvironment,
         }, true);
     }
-    if (!schema.skipTsConfig) {
+    if (!schema.skipTsConfig && !options.isUsingTsSolutionConfig) {
         (0, ts_config_1.addTsConfigPath)(tree, options.importPath, [
             (0, devkit_1.joinPathFragments)(options.projectRoot, './src', 'index.' + (options.js ? 'js' : 'ts')),
         ]);
     }
-    if (options.bundler !== 'none') {
-        addBundlerDependencies(tree, options);
+    if (options.isUsingTsSolutionConfig && options.unitTestRunner !== 'none') {
+        (0, devkit_1.updateJson)(tree, (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.spec.json'), (json) => {
+            const rootOffset = (0, devkit_1.offsetFromRoot)(options.projectRoot);
+            // ensure it extends from the root tsconfig.base.json
+            json.extends = (0, devkit_1.joinPathFragments)(rootOffset, 'tsconfig.base.json');
+            // ensure outDir is set to the correct value
+            json.compilerOptions ??= {};
+            json.compilerOptions.outDir = (0, devkit_1.joinPathFragments)(rootOffset, 'dist/out-tsc', options.projectRoot);
+            // add project reference to the runtime tsconfig.lib.json file
+            json.references ??= [];
+            json.references.push({ path: './tsconfig.lib.json' });
+            return json;
+        });
     }
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }
+    if (options.isUsingTsSolutionConfig &&
+        options.projectPackageManagerWorkspaceState !== 'included') {
+        tasks.push((0, package_manager_workspaces_2.getProjectPackageManagerWorkspaceStateWarningTask)(options.projectPackageManagerWorkspaceState, tree.root));
+    }
     if (options.publishable) {
         tasks.push(() => {
             logNxReleaseDocsInfo();
@@ -119,7 +145,28 @@ async function libraryGeneratorInternal(tree, schema) {
     });
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
-async function addProject(tree, options) {
+async function configureProject(tree, options) {
+    if (options.hasPlugin) {
+        const nxJson = (0, devkit_1.readNxJson)(tree);
+        if (options.bundler === 'none') {
+            (0, plugin_registrations_1.ensureProjectIsExcludedFromPluginRegistrations)(nxJson, options.projectRoot);
+        }
+        else {
+            (0, plugin_registrations_1.ensureProjectIsIncludedInPluginRegistrations)(nxJson, options.projectRoot);
+        }
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+    if (!options.useProjectJson) {
+        if (options.name !== options.importPath) {
+            // if the name is different than the package.json name, we need to set
+            // the proper name in the configuration
+            (0, devkit_1.updateProjectConfiguration)(tree, options.name, {
+                name: options.name,
+                root: options.projectRoot,
+            });
+        }
+        return;
+    }
     const projectConfiguration = {
         root: options.projectRoot,
         sourceRoot: (0, devkit_1.joinPathFragments)(options.projectRoot, 'src'),
@@ -185,7 +232,7 @@ async function addProject(tree, options) {
             root: projectConfiguration.root,
             tags: projectConfiguration.tags,
             targets: {},
-        }, true);
+        });
     }
 }
 async function addLint(tree, options) {
@@ -267,39 +314,6 @@ async function addLint(tree, options) {
     }
     return task;
 }
-function addBundlerDependencies(tree, options) {
-    (0, devkit_1.updateJson)(tree, `${options.projectRoot}/package.json`, (json) => {
-        if (options.bundler === 'tsc') {
-            json.dependencies = {
-                ...json.dependencies,
-                tslib: versions_1.tsLibVersion,
-            };
-        }
-        else if (options.bundler === 'swc') {
-            json.dependencies = {
-                ...json.dependencies,
-                '@swc/helpers': versions_1.swcHelpersVersion,
-            };
-        }
-        return json;
-    });
-}
-function updateTsConfig(tree, options) {
-    (0, devkit_1.updateJson)(tree, (0, path_1.join)(options.projectRoot, 'tsconfig.json'), (json) => {
-        if (options.strict) {
-            json.compilerOptions = {
-                ...json.compilerOptions,
-                forceConsistentCasingInFileNames: true,
-                strict: true,
-                noImplicitOverride: true,
-                noPropertyAccessFromIndexSignature: true,
-                noImplicitReturns: true,
-                noFallthroughCasesInSwitch: true,
-            };
-        }
-        return json;
-    });
-}
 function addBabelRc(tree, options) {
     const filename = '.babelrc';
     const babelrc = {
@@ -309,7 +323,7 @@ function addBabelRc(tree, options) {
 }
 function createFiles(tree, options) {
     const { className, name, propertyName } = (0, devkit_1.names)(options.projectNames.projectFileName);
-    createProjectTsConfigJson(tree, options);
+    createProjectTsConfigs(tree, options);
     (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, './files/lib'), options.projectRoot, {
         ...options,
         dot: '.',
@@ -341,7 +355,6 @@ function createFiles(tree, options) {
         });
     }
     if (options.bundler === 'swc' || options.bundler === 'rollup') {
-        (0, add_swc_dependencies_1.addSwcDependencies)(tree);
         (0, add_swc_config_1.addSwcConfig)(tree, options.projectRoot, options.bundler === 'swc' ? 'commonjs' : 'es6');
     }
     else if (options.includeBabelRc) {
@@ -366,6 +379,11 @@ function createFiles(tree, options) {
             if (!options.publishable && !options.rootProject) {
                 json.private = true;
             }
+            if (options.isUsingTsSolutionConfig && options.publishable) {
+                // package.json and README.md are always included by default
+                // https://docs.npmjs.com/cli/v10/configuring-npm/package-json#files
+                json.files = ['dist', '!**/*.tsbuildinfo'];
+            }
             return {
                 ...json,
                 dependencies: {
@@ -386,6 +404,11 @@ function createFiles(tree, options) {
         if (!options.publishable && !options.rootProject) {
             packageJson.private = true;
         }
+        if (options.isUsingTsSolutionConfig && options.publishable) {
+            // package.json and README.md are always included by default
+            // https://docs.npmjs.com/cli/v10/configuring-npm/package-json#files
+            packageJson.files = ['dist', '!**/*.tsbuildinfo'];
+        }
         (0, devkit_1.writeJson)(tree, packageJsonPath, packageJson);
     }
     if (options.config === 'npm-scripts') {
@@ -397,14 +420,9 @@ function createFiles(tree, options) {
             return json;
         });
     }
-    else if ((!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'));
     }
-    updateTsConfig(tree, options);
 }
 async function addJest(tree, options) {
     const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/jest', versions_1.nxVersion);
@@ -443,33 +461,117 @@ function replaceJestConfig(tree, options) {
         testEnvironment: options.testEnvironment,
     });
 }
+function isNonInteractive() {
+    return ((0, is_ci_1.isCI)() || !process.stdout.isTTY || process.env.NX_INTERACTIVE !== 'true');
+}
+async function promptWhenInteractive(questions, defaultValue) {
+    if (isNonInteractive()) {
+        return defaultValue;
+    }
+    return await (0, enquirer_1.prompt)(questions);
+}
 async function normalizeOptions(tree, options) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
-    const addPlugin = process.env.NX_ADD_PLUGINS !== 'false' &&
-        nxJson.useInferencePlugins !== false;
-    options.addPlugin ??= addPlugin;
-    /**
-     * We are deprecating the compiler and the buildable options.
-     * However, we want to keep the existing behavior for now.
-     *
-     * So, if the user has not provided a bundler, we will use the compiler option, if any.
-     *
-     * If the user has not provided a bundler and no compiler, but has set buildable to true,
-     * we will use tsc, since that is the compiler the old generator used to default to, if buildable was true
-     * and no compiler was provided.
-     *
-     * If the user has not provided a bundler and no compiler, and has not set buildable to true, then
-     * set the bundler to tsc, to preserve old default behaviour (buildable: true by default).
-     *
-     * If it's publishable, we need to build the code before publishing it, so again
-     * we default to `tsc`. In the previous version of this, it would set `buildable` to true
-     * and that would default to `tsc`.
-     *
-     * In the past, the only way to get a non-buildable library was to set buildable to false.
-     * Now, the only way to get a non-buildble library is to set bundler to none.
-     * By default, with nothing provided, libraries are buildable with `@nx/js:tsc`.
-     */
-    options.bundler = options.bundler ?? options.compiler ?? 'tsc';
+    options.addPlugin ??=
+        process.env.NX_ADD_PLUGINS !== 'false' &&
+            nxJson.useInferencePlugins !== false;
+    const hasPlugin = (0, ts_solution_setup_1.isUsingTypeScriptPlugin)(tree);
+    const isUsingTsSolutionConfig = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree);
+    if (isUsingTsSolutionConfig) {
+        if (options.bundler === 'esbuild' || options.bundler === 'swc') {
+            throw new Error(`Cannot use the "${options.bundler}" bundler when using the @nx/js/typescript plugin.`);
+        }
+        if (options.bundler === undefined && options.compiler === undefined) {
+            options.bundler = await promptWhenInteractive({
+                type: 'select',
+                name: 'bundler',
+                message: `Which bundler would you like to use to build the library? Choose 'none' to skip build setup.`,
+                choices: [
+                    { name: 'tsc' },
+                    { name: 'rollup' },
+                    { name: 'vite' },
+                    { name: 'none' },
+                ],
+                initial: 0,
+            }, { bundler: 'tsc' }).then(({ bundler }) => bundler);
+        }
+        options.linter ??= await promptWhenInteractive({
+            type: 'select',
+            name: 'linter',
+            message: `Which linter would you like to use?`,
+            choices: [{ name: 'none' }, { name: 'eslint' }],
+            initial: 0,
+        }, { linter: 'none' }).then(({ linter }) => linter);
+        options.unitTestRunner ??= await promptWhenInteractive({
+            type: 'select',
+            name: 'unitTestRunner',
+            message: `Which unit test runner would you like to use?`,
+            choices: [{ name: 'none' }, { name: 'vitest' }, { name: 'jest' }],
+            initial: 0,
+        }, { unitTestRunner: 'none' }).then(({ unitTestRunner }) => unitTestRunner);
+    }
+    else {
+        if (options.bundler === undefined && options.compiler === undefined) {
+            options.bundler = await promptWhenInteractive({
+                type: 'select',
+                name: 'bundler',
+                message: `Which bundler would you like to use to build the library? Choose 'none' to skip build setup.`,
+                choices: [
+                    { name: 'swc' },
+                    { name: 'tsc' },
+                    { name: 'rollup' },
+                    { name: 'vite' },
+                    { name: 'esbuild' },
+                    { name: 'none' },
+                ],
+                initial: 1,
+            }, { bundler: 'tsc' }).then(({ bundler }) => bundler);
+        }
+        else {
+            /**
+             * We are deprecating the compiler and the buildable options.
+             * However, we want to keep the existing behavior for now.
+             *
+             * So, if the user has not provided a bundler, we will use the compiler option, if any.
+             *
+             * If the user has not provided a bundler and no compiler, but has set buildable to true,
+             * we will use tsc, since that is the compiler the old generator used to default to, if buildable was true
+             * and no compiler was provided.
+             *
+             * If the user has not provided a bundler and no compiler, and has not set buildable to true, then
+             * set the bundler to tsc, to preserve old default behaviour (buildable: true by default).
+             *
+             * If it's publishable, we need to build the code before publishing it, so again
+             * we default to `tsc`. In the previous version of this, it would set `buildable` to true
+             * and that would default to `tsc`.
+             *
+             * In the past, the only way to get a non-buildable library was to set buildable to false.
+             * Now, the only way to get a non-buildble library is to set bundler to none.
+             * By default, with nothing provided, libraries are buildable with `@nx/js:tsc`.
+             */
+            options.bundler ??= options.compiler;
+        }
+        options.linter ??= await promptWhenInteractive({
+            type: 'select',
+            name: 'linter',
+            message: `Which linter would you like to use?`,
+            choices: [{ name: 'eslint' }, { name: 'none' }],
+            initial: 0,
+        }, { linter: 'eslint' }).then(({ linter }) => linter);
+        options.unitTestRunner ??= await promptWhenInteractive({
+            type: 'select',
+            name: 'unitTestRunner',
+            message: `Which unit test runner would you like to use?`,
+            choices: [{ name: 'jest' }, { name: 'vitest' }, { name: 'none' }],
+            initial: 0,
+        }, { unitTestRunner: undefined }).then(({ unitTestRunner }) => unitTestRunner);
+        if (!options.unitTestRunner && options.bundler === 'vite') {
+            options.unitTestRunner = 'vitest';
+        }
+        else if (!options.unitTestRunner && options.config !== 'npm-scripts') {
+            options.unitTestRunner = 'jest';
+        }
+    }
     // ensure programmatic runs have an expected default
     if (!options.config) {
         options.config = 'project';
@@ -486,25 +588,15 @@ async function normalizeOptions(tree, options) {
     if (options.publishable === false && options.buildable === false) {
         options.bundler = 'none';
     }
-    const { Linter } = (0, devkit_1.ensurePackage)('@nx/eslint', versions_1.nxVersion);
     if (options.config === 'npm-scripts') {
         options.unitTestRunner = 'none';
-        options.linter = Linter.None;
+        options.linter = 'none';
         options.bundler = 'none';
     }
     if ((options.bundler === 'swc' || options.bundler === 'rollup') &&
         options.skipTypeCheck == null) {
         options.skipTypeCheck = false;
     }
-    if (!options.unitTestRunner && options.bundler === 'vite') {
-        options.unitTestRunner = 'vitest';
-    }
-    else if (!options.unitTestRunner && options.config !== 'npm-scripts') {
-        options.unitTestRunner = 'jest';
-    }
-    if (!options.linter && options.config !== 'npm-scripts') {
-        options.linter = Linter.EsLint;
-    }
     const { projectName, names: projectNames, projectRoot, importPath, } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(tree, {
         name: options.name,
         projectType: 'library',
@@ -521,6 +613,9 @@ async function normalizeOptions(tree, options) {
         ? options.tags.split(',').map((s) => s.trim())
         : [];
     options.minimal ??= false;
+    const projectPackageManagerWorkspaceState = (0, package_manager_workspaces_1.getProjectPackageManagerWorkspaceState)(tree, projectRoot);
+    // We default to generate a project.json file if the new setup is not being used
+    options.useProjectJson ??= !isUsingTsSolutionConfig;
     return {
         ...options,
         fileName,
@@ -529,6 +624,9 @@ async function normalizeOptions(tree, options) {
         projectRoot,
         parsedTags,
         importPath,
+        hasPlugin,
+        isUsingTsSolutionConfig,
+        projectPackageManagerWorkspaceState,
     };
 }
 function addProjectDependencies(tree, options) {
@@ -540,7 +638,19 @@ function addProjectDependencies(tree, options) {
         });
     }
     else if (options.bundler == 'rollup') {
-        return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@nx/rollup': versions_1.nxVersion, '@types/node': versions_1.typesNodeVersion });
+        const { dependencies, devDependencies } = (0, add_swc_dependencies_1.getSwcDependencies)();
+        return (0, devkit_1.addDependenciesToPackageJson)(tree, { ...dependencies }, {
+            ...devDependencies,
+            '@nx/rollup': versions_1.nxVersion,
+            '@types/node': versions_1.typesNodeVersion,
+        });
+    }
+    else if (options.bundler === 'tsc') {
+        return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { tslib: versions_1.tsLibVersion, '@types/node': versions_1.typesNodeVersion });
+    }
+    else if (options.bundler === 'swc') {
+        const { dependencies, devDependencies } = (0, add_swc_dependencies_1.getSwcDependencies)();
+        return (0, devkit_1.addDependenciesToPackageJson)(tree, { ...dependencies }, { ...devDependencies, '@types/node': versions_1.typesNodeVersion });
     }
     else {
         return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@types/node': versions_1.typesNodeVersion });
@@ -575,15 +685,92 @@ function getOutputPath(options) {
     }
     return (0, devkit_1.joinPathFragments)(...parts);
 }
-function createProjectTsConfigJson(tree, 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) {
+        // 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
+        (0, ts_config_1.getRootTsConfigFileName)(tree));
+    }
+    // tsconfig.lib.json
+    (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, 'files/tsconfig-lib', options.isUsingTsSolutionConfig ? 'ts-solution' : 'non-ts-solution'), options.projectRoot, {
+        ...options,
+        offsetFromRoot: rootOffset,
+        js: !!options.js,
+        compilerOptions: Object.entries(compilerOptionOverrides)
+            .map(([k, v]) => `${JSON.stringify(k)}: ${JSON.stringify(v)}`)
+            .join(',\n    '),
+        tmpl: '',
+    });
+    // tsconfig.json
+    if (options.isUsingTsSolutionConfig) {
+        if (options.rootProject) {
+            // the root tsconfig.json is already created with the expected settings
+            // for the TS plugin, we just need to update it with the project-specific
+            // settings
+            (0, devkit_1.updateJson)(tree, 'tsconfig.json', (json) => {
+                json.references.push({
+                    path: './tsconfig.lib.json',
+                });
+                return json;
+            });
+        }
+        else {
+            // create a new tsconfig.json for the project
+            const tsconfig = {
+                extends: (0, ts_config_1.getRelativePathToRootTsConfig)(tree, options.projectRoot),
+                files: [],
+                include: [],
+                references: [{ path: './tsconfig.lib.json' }],
+            };
+            (0, devkit_1.writeJson)(tree, (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.json'), tsconfig);
+            // update root project tsconfig.json references with the new lib tsconfig
+            (0, devkit_1.updateJson)(tree, 'tsconfig.json', (json) => {
+                json.references ??= [];
+                json.references.push({
+                    path: options.projectRoot.startsWith('./')
+                        ? options.projectRoot
+                        : './' + options.projectRoot,
+                });
+                return json;
+            });
+        }
+        return;
+    }
     const tsconfig = {
         extends: options.rootProject
             ? undefined
             : (0, ts_config_1.getRelativePathToRootTsConfig)(tree, options.projectRoot),
         compilerOptions: {
             ...(options.rootProject ? create_ts_config_1.tsConfigBaseOptions : {}),
-            module: 'commonjs',
-            allowJs: options.js ? true : undefined,
+            ...compilerOptionOverrides,
         },
         files: [],
         include: [],
@@ -618,8 +805,12 @@ function determineEntryFields(options) {
         case 'tsc':
             return {
                 type: 'commonjs',
-                main: './src/index.js',
-                typings: './src/index.d.ts',
+                main: options.isUsingTsSolutionConfig
+                    ? './dist/index.js'
+                    : './src/index.js',
+                typings: options.isUsingTsSolutionConfig
+                    ? './dist/index.d.ts'
+                    : './src/index.d.ts',
             };
         case 'swc':
             return {
@@ -631,16 +822,26 @@ function determineEntryFields(options) {
             return {
                 // Since we're publishing both formats, skip the type field.
                 // Bundlers or Node will determine the entry point to use.
-                main: './index.cjs',
-                module: './index.js',
+                main: options.isUsingTsSolutionConfig
+                    ? './dist/index.cjs'
+                    : './index.cjs',
+                module: options.isUsingTsSolutionConfig
+                    ? './dist/index.js'
+                    : './index.js',
             };
         case 'vite':
             return {
                 // Since we're publishing both formats, skip the type field.
                 // Bundlers or Node will determine the entry point to use.
-                main: './index.js',
-                module: './index.mjs',
-                typings: './index.d.ts',
+                main: options.isUsingTsSolutionConfig
+                    ? './dist/index.js'
+                    : './index.js',
+                module: options.isUsingTsSolutionConfig
+                    ? './dist/index.mjs'
+                    : './index.mjs',
+                typings: options.isUsingTsSolutionConfig
+                    ? './dist/index.d.ts'
+                    : './index.d.ts',
             };
         case 'esbuild':
             // For libraries intended for Node, use CJS.

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

@@ -0,0 +1,53 @@
+import type {
+  ProjectNameAndRootFormat,
+  ProjectNameAndRootOptions,
+} from '@nx/devkit/src/generators/project-name-and-root-utils';
+// nx-ignore-next-line
+const { Linter, LinterType } = require('@nx/eslint'); // use require to import to avoid circular dependency
+import type { ProjectPackageManagerWorkspaceState } from '../../utils/package-manager-workspaces';
+
+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;
+  pascalCaseFiles?: 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;
+  useProjectJson?: boolean;
+}
+
+export interface NormalizedLibraryGeneratorOptions
+  extends LibraryGeneratorSchema {
+  name: string;
+  projectNames: ProjectNameAndRootOptions['names'];
+  fileName: string;
+  projectRoot: string;
+  parsedTags: string[];
+  importPath?: string;
+  hasPlugin: boolean;
+  isUsingTsSolutionConfig: boolean;
+  projectPackageManagerWorkspaceState: ProjectPackageManagerWorkspaceState;
+}