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

package/src/generators/migration/migration.js

@@ -1,50 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.migrationGenerator = migrationGenerator;
-exports.migrationGeneratorInternal = migrationGeneratorInternal;
 const devkit_1 = require("@nx/devkit");
-const path = require("path");
-const path_1 = require("path");
-const generator_1 = require("../lint-checks/generator");
+const artifact_name_and_directory_utils_1 = require("@nx/devkit/src/generators/artifact-name-and-directory-utils");
+const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const node_path_1 = require("node:path");
 const package_json_1 = require("nx/src/utils/package-json");
+const paths_1 = require("../../utils/paths");
 const versions_1 = require("../../utils/versions");
-const artifact_name_and_directory_utils_1 = require("@nx/devkit/src/generators/artifact-name-and-directory-utils");
+const generator_1 = require("../lint-checks/generator");
 async function normalizeOptions(tree, options) {
-    let name;
-    if (options.name) {
-        name = (0, devkit_1.names)(options.name).fileName;
-    }
-    else {
-        name = (0, devkit_1.names)(`update-${options.packageVersion}`).fileName;
-    }
-    const { project, fileName, artifactName, filePath, directory } = await (0, artifact_name_and_directory_utils_1.determineArtifactNameAndDirectoryOptions)(tree, {
-        artifactType: 'migration',
-        callingGenerator: '@nx/plugin:migration',
-        name: name,
-        nameAndDirectoryFormat: options.nameAndDirectoryFormat,
-        project: options.project,
-        directory: options.directory,
-        fileName: name,
-        derivedDirectory: 'migrations',
+    const { artifactName: name, directory, fileName, project, } = await (0, artifact_name_and_directory_utils_1.determineArtifactNameAndDirectoryOptions)(tree, {
+        path: options.path,
+        name: options.name,
+        allowedFileExtensions: ['ts'],
+        fileExtension: 'ts',
     });
-    const { className, propertyName } = (0, devkit_1.names)(artifactName);
     const { root: projectRoot, sourceRoot: projectSourceRoot } = (0, devkit_1.readProjectConfiguration)(tree, project);
     const description = options.description ?? `Migration for v${options.packageVersion}`;
-    // const { root: projectRoot, sourceRoot: projectSourceRoot } =
-    //   readProjectConfiguration(host, options.project);
     const normalized = {
         ...options,
-        project,
-        name: artifactName,
         directory,
+        fileName,
+        project,
+        name,
         description,
         projectRoot,
-        projectSourceRoot,
+        projectSourceRoot: projectSourceRoot ?? (0, node_path_1.join)(projectRoot, 'src'),
+        isTsSolutionSetup: (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree),
     };
     return normalized;
 }
 function addFiles(host, options) {
-    (0, devkit_1.generateFiles)(host, path.join(__dirname, 'files/migration'), options.directory, { ...options, tmpl: '' });
+    (0, devkit_1.generateFiles)(host, (0, node_path_1.join)(__dirname, 'files/migration'), options.directory, {
+        ...options,
+        tmpl: '',
+    });
 }
 function updateMigrationsJson(host, options) {
     const configuredMigrationPath = (0, package_json_1.readNxMigrateConfig)((0, devkit_1.readJson)(host, (0, devkit_1.joinPathFragments)(options.projectRoot, 'package.json'))).migrations;
@@ -53,10 +44,11 @@ function updateMigrationsJson(host, options) {
         ? (0, devkit_1.readJson)(host, migrationsPath)
         : {};
     const generators = migrations.generators ?? {};
+    const dir = (0, paths_1.getArtifactMetadataDirectory)(host, options.project, options.directory, options.isTsSolutionSetup);
     generators[options.name] = {
         version: options.packageVersion,
         description: options.description,
-        implementation: `./${(0, devkit_1.joinPathFragments)((0, path_1.relative)(options.projectRoot, options.directory), options.name)}`,
+        implementation: `${dir}/${options.fileName}`,
     };
     migrations.generators = generators;
     if (options.packageJsonUpdates) {
@@ -72,10 +64,17 @@ function updateMigrationsJson(host, options) {
     (0, devkit_1.writeJson)(host, migrationsPath, migrations);
 }
 function updatePackageJson(host, options) {
-    (0, devkit_1.updateJson)(host, path.join(options.projectRoot, 'package.json'), (json) => {
+    (0, devkit_1.updateJson)(host, (0, node_path_1.join)(options.projectRoot, 'package.json'), (json) => {
+        const addFile = (file) => {
+            if (options.isTsSolutionSetup) {
+                const filesSet = new Set(json.files ?? ['dist', '!**/*.tsbuildinfo']);
+                filesSet.add(file.replace(/^\.\//, ''));
+                json.files = [...filesSet];
+            }
+        };
         const migrationKey = json['ng-update'] ? 'ng-update' : 'nx-migrations';
-        const preexistingValue = json[migrationKey];
-        if (typeof preexistingValue === 'string') {
+        if (typeof json[migrationKey] === 'string') {
+            addFile(json[migrationKey]);
             return json;
         }
         else if (!json[migrationKey]) {
@@ -83,9 +82,10 @@ function updatePackageJson(host, options) {
                 migrations: './migrations.json',
             };
         }
-        else if (preexistingValue.migrations) {
-            preexistingValue.migrations = './migrations.json';
+        else if (json[migrationKey].migrations) {
+            json[migrationKey].migrations = './migrations.json';
         }
+        addFile(json[migrationKey].migrations);
         // add dependencies
         json.dependencies = {
             '@nx/devkit': versions_1.nxVersion,
@@ -95,6 +95,9 @@ function updatePackageJson(host, options) {
     });
 }
 function updateProjectConfig(host, options) {
+    if (options.isTsSolutionSetup) {
+        return;
+    }
     const project = (0, devkit_1.readProjectConfiguration)(host, options.project);
     const assets = project.targets.build?.options?.assets;
     if (assets &&
@@ -110,19 +113,12 @@ function updateProjectConfig(host, options) {
         (0, devkit_1.updateProjectConfiguration)(host, options.project, project);
     }
 }
-async function migrationGenerator(tree, rawOptions) {
-    await migrationGeneratorInternal(tree, {
-        nameAndDirectoryFormat: 'derived',
-        ...rawOptions,
-    });
-}
-async function migrationGeneratorInternal(host, schema) {
+async function migrationGenerator(host, schema) {
     const options = await normalizeOptions(host, schema);
     addFiles(host, options);
+    updatePackageJson(host, options);
     updateMigrationsJson(host, options);
     updateProjectConfig(host, options);
-    updateMigrationsJson(host, options);
-    updatePackageJson(host, options);
     if (!host.exists('migrations.json')) {
         const packageJsonPath = (0, devkit_1.joinPathFragments)(options.projectRoot, 'package.json');
         (0, generator_1.addMigrationJsonChecks)(host, { projectName: options.project }, (0, devkit_1.readJson)(host, packageJsonPath));

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

@@ -1,16 +1,8 @@
-import { NameAndDirectoryFormat } from '@nx/devkit/src/generators/artifact-name-and-directory-utils';
-
 export interface Schema {
+  path: string;
   name?: string;
-  directory?: string;
   description?: string;
   packageVersion: string;
   packageJsonUpdates?: boolean;
   skipFormat?: boolean;
-  nameAndDirectoryFormat?: NameAndDirectoryFormat;
-
-  /**
-   * @deprecated Provide the `directory` option instead. The project will be determined from the directory provided. It will be removed in Nx v20.
-   */
-  project?: string;
 }

package/src/generators/migration/schema.json

@@ -7,24 +7,32 @@
   "type": "object",
   "examples": [
     {
-      "command": "nx g migration my-migration --project=my-plugin --version=1.0.0",
-      "description": "Adds a new migration to the project `my-plugin`, which will be triggered when migrating to version 1.0.0 or above from a previous version."
+      "description": "Generate a migration exported with the name matching the file name, which will be triggered when migrating to version 1.0.0 or above from a previous version. It results in the migration `foo` at `mylib/src/migrations/foo.ts`",
+      "command": "nx g @nx/plugin:migration mylib/src/migrations/foo.ts -v=1.0.0"
+    },
+    {
+      "description": "Generate a migration without providing the file extension, which will be triggered when migrating to version 1.0.0 or above from a previous version. It results in the migration `foo` at `mylib/src/migrations/foo.ts`",
+      "command": "nx g @nx/plugin:migration mylib/src/migrations/foo -v=1.0.0"
+    },
+    {
+      "description": "Generate a migration exported with a different name from the file name, which will be triggered when migrating to version 1.0.0 or above from a previous version. It results in the migration `custom` at `mylib/src/migrations/foo.ts`",
+      "command": "nx g @nx/plugin:migration mylib/src/migrations/foo --name=custom -v=1.0.0"
     }
   ],
   "properties": {
-    "name": {
+    "path": {
       "type": "string",
-      "description": "Migration name.",
+      "description": "The file path to the migration without the file extension. Relative to the current working directory.",
       "$default": {
         "$source": "argv",
         "index": 0
       },
+      "x-prompt": "What is the migration file path?",
       "x-priority": "important"
     },
-    "directory": {
+    "name": {
       "type": "string",
-      "description": "The directory at which to create the migration file. When `--nameAndDirectoryFormat=as-provided`, it will be relative to the current working directory. Otherwise, it will be relative to the workspace root.",
-      "aliases": ["dir"]
+      "description": "The migration name to export in the plugin migrations collection."
     },
     "description": {
       "type": "string",
@@ -37,15 +45,6 @@
       "x-prompt": "What version would you like to use for the migration?",
       "x-priority": "important"
     },
-    "project": {
-      "type": "string",
-      "description": "The name of the project.",
-      "alias": "p",
-      "$default": {
-        "$source": "projectName"
-      },
-      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. The project will be determined from the directory provided. It will be removed in Nx v20."
-    },
     "packageJsonUpdates": {
       "type": "boolean",
       "description": "Whether or not to include `package.json` updates.",
@@ -56,13 +55,8 @@
       "type": "boolean",
       "default": false,
       "description": "Do not eslint configuration for plugin json files."
-    },
-    "nameAndDirectoryFormat": {
-      "description": "Whether to generate the migration in the directory as provided, relative to the current working directory and ignoring the project (`as-provided`) or generate it using the project and directory relative to the workspace root (`derived`).",
-      "type": "string",
-      "enum": ["as-provided", "derived"]
     }
   },
-  "required": ["packageVersion"],
+  "required": ["packageVersion", "path"],
   "additionalProperties": false
 }

package/src/generators/plugin/plugin.d.ts

@@ -1,5 +1,5 @@
 import { GeneratorCallback, Tree } from '@nx/devkit';
 import type { Schema } from './schema';
-export declare function pluginGenerator(host: Tree, schema: Schema): Promise<GeneratorCallback>;
+export declare function pluginGenerator(tree: Tree, schema: Schema): Promise<GeneratorCallback>;
 export declare function pluginGeneratorInternal(host: Tree, schema: Schema): Promise<GeneratorCallback>;
 export default pluginGenerator;

package/src/generators/plugin/plugin.js

@@ -5,13 +5,11 @@ exports.pluginGeneratorInternal = pluginGeneratorInternal;
 const devkit_1 = require("@nx/devkit");
 const js_1 = require("@nx/js");
 const add_swc_dependencies_1 = require("@nx/js/src/utils/swc/add-swc-dependencies");
-const eslint_1 = require("@nx/eslint");
+const add_tslib_dependencies_1 = require("@nx/js/src/utils/typescript/add-tslib-dependencies");
 const path = require("path");
 const e2e_1 = require("../e2e-project/e2e");
 const generator_1 = require("../lint-checks/generator");
 const normalize_schema_1 = require("./utils/normalize-schema");
-const add_tslib_dependencies_1 = require("@nx/js/src/utils/typescript/add-tslib-dependencies");
-const add_swc_dependencies_2 = require("@nx/js/src/utils/swc/add-swc-dependencies");
 const nxVersion = require('../../../package.json').version;
 async function addFiles(host, options) {
     host.delete((0, devkit_1.normalizePath)(`${options.projectRoot}/src/lib`));
@@ -21,39 +19,30 @@ async function addFiles(host, options) {
     });
 }
 function updatePluginConfig(host, options) {
-    const project = (0, devkit_1.readProjectConfiguration)(host, options.name);
+    const project = (0, devkit_1.readProjectConfiguration)(host, options.projectName);
     if (project.targets.build) {
-        project.targets.build.options.assets ??= [];
-        const root = options.projectRoot === '.' ? '.' : './' + options.projectRoot;
+        if (options.isTsSolutionSetup && options.bundler === 'tsc') {
+            project.targets.build.options.rootDir =
+                project.sourceRoot ?? (0, devkit_1.joinPathFragments)(project.root, 'src');
+            project.targets.build.options.generatePackageJson = false;
+        }
         project.targets.build.options.assets = [
-            ...project.targets.build.options.assets,
-            {
-                input: `${root}/src`,
-                glob: '**/!(*.ts)',
-                output: './src',
-            },
-            {
-                input: `${root}/src`,
-                glob: '**/*.d.ts',
-                output: './src',
-            },
-            {
-                input: root,
-                glob: 'generators.json',
-                output: '.',
-            },
-            {
-                input: root,
-                glob: 'executors.json',
-                output: '.',
-            },
+            ...(project.targets.build.options.assets ?? []),
         ];
-        (0, devkit_1.updateProjectConfiguration)(host, options.name, project);
+        const root = options.projectRoot === '.' ? '.' : './' + options.projectRoot;
+        if (options.isTsSolutionSetup) {
+            project.targets.build.options.assets.push({ input: `${root}/src`, glob: '**/!(*.ts)', output: '.' }, { input: `${root}/src`, glob: '**/*.d.ts', output: '.' });
+        }
+        else {
+            project.targets.build.options.assets.push({ input: `${root}/src`, glob: '**/!(*.ts)', output: './src' }, { input: `${root}/src`, glob: '**/*.d.ts', output: './src' }, { input: root, glob: 'generators.json', output: '.' }, { input: root, glob: 'executors.json', output: '.' });
+        }
+        (0, devkit_1.updateProjectConfiguration)(host, options.projectName, project);
     }
 }
-async function pluginGenerator(host, schema) {
-    return await pluginGeneratorInternal(host, {
-        projectNameAndRootFormat: 'derived',
+async function pluginGenerator(tree, schema) {
+    return await pluginGeneratorInternal(tree, {
+        useProjectJson: true,
+        addPlugin: false,
         ...schema,
     });
 }
@@ -67,39 +56,51 @@ async function pluginGeneratorInternal(host, schema) {
         config: 'project',
         bundler: options.bundler,
         publishable: options.publishable,
-        importPath: options.npmPackageName,
-        projectNameAndRootFormat: 'as-provided',
+        importPath: options.importPath,
+        linter: options.linter,
+        unitTestRunner: options.unitTestRunner,
+        useProjectJson: options.useProjectJson,
+        addPlugin: options.addPlugin,
         skipFormat: true,
+        useTscExecutor: true,
     }));
+    if (options.isTsSolutionSetup) {
+        (0, devkit_1.updateJson)(host, (0, devkit_1.joinPathFragments)(options.projectRoot, 'package.json'), (json) => {
+            delete json.type;
+            return json;
+        });
+    }
     if (options.bundler === 'tsc') {
         tasks.push((0, add_tslib_dependencies_1.addTsLibDependencies)(host));
     }
     tasks.push((0, devkit_1.addDependenciesToPackageJson)(host, {
         '@nx/devkit': nxVersion,
     }, {
-        '@nx/jest': nxVersion,
+        [options.unitTestRunner === 'vitest' ? '@nx/vite' : '@nx/jest']: nxVersion,
         '@nx/js': nxVersion,
         '@nx/plugin': nxVersion,
     }));
     // Ensures Swc Deps are installed to handle running
     // local plugin generators and executors
     tasks.push((0, add_swc_dependencies_1.addSwcDependencies)(host));
-    tasks.push((0, add_swc_dependencies_2.addSwcRegisterDependencies)(host));
+    tasks.push((0, add_swc_dependencies_1.addSwcRegisterDependencies)(host));
     await addFiles(host, options);
     updatePluginConfig(host, options);
     if (options.e2eTestRunner !== 'none') {
         tasks.push(await (0, e2e_1.e2eProjectGenerator)(host, {
-            pluginName: options.name,
+            pluginName: options.projectName,
             projectDirectory: options.projectDirectory,
-            pluginOutputPath: (0, devkit_1.joinPathFragments)('dist', options.rootProject ? options.name : options.projectRoot),
-            npmPackageName: options.npmPackageName,
+            pluginOutputPath: (0, devkit_1.joinPathFragments)('dist', options.rootProject ? options.projectName : options.projectRoot),
+            npmPackageName: options.importPath,
             skipFormat: true,
             rootProject: options.rootProject,
-            projectNameAndRootFormat: options.projectNameAndRootFormat,
+            linter: options.linter,
+            useProjectJson: options.useProjectJson,
+            addPlugin: options.addPlugin,
         }));
     }
-    if (options.linter === eslint_1.Linter.EsLint && !options.skipLintChecks) {
-        await (0, generator_1.default)(host, { projectName: options.name });
+    if (options.linter === 'eslint' && !options.skipLintChecks) {
+        await (0, generator_1.default)(host, { projectName: options.projectName });
     }
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(host);

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

@@ -1,20 +1,20 @@
-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;
   importPath?: string;
   skipTsConfig?: boolean; // default is false
   skipFormat?: boolean; // default is false
   skipLintChecks?: boolean; // default is false
   e2eTestRunner?: 'jest' | 'none';
   tags?: string;
-  unitTestRunner: 'jest' | 'none';
-  linter: Linter | LinterType;
+  unitTestRunner?: 'jest' | 'vitest' | 'none';
+  linter?: Linter | LinterType;
   setParserOptionsProject?: boolean;
-  compiler: 'swc' | 'tsc';
+  compiler?: 'swc' | 'tsc';
   rootProject?: boolean;
   publishable?: boolean;
+  useProjectJson?: boolean;
+  addPlugin?: boolean;
 }

package/src/generators/plugin/schema.json

@@ -12,25 +12,19 @@
     }
   ],
   "properties": {
-    "name": {
+    "directory": {
       "type": "string",
-      "description": "Plugin name",
+      "description": "A directory where the plugin is placed.",
       "$default": {
         "$source": "argv",
         "index": 0
       },
-      "x-prompt": "What name would you like to use for the plugin?",
-      "x-priority": "important",
-      "pattern": "(?:^@[a-zA-Z0-9-*~][a-zA-Z0-9-*._~]*\\/[a-zA-Z0-9-~][a-zA-Z0-9-._~]*|^[a-zA-Z][^:]*)$"
-    },
-    "directory": {
-      "type": "string",
-      "description": "A directory where the plugin is placed."
+      "x-prompt": "Which directory do you want to create the plugin in?"
     },
-    "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`).",
+    "name": {
       "type": "string",
-      "enum": ["as-provided", "derived"]
+      "description": "Plugin name",
+      "x-priority": "important"
     },
     "importPath": {
       "type": "string",
@@ -40,14 +34,14 @@
     "linter": {
       "description": "The tool to use for running lint checks.",
       "type": "string",
-      "enum": ["eslint"],
-      "default": "eslint"
+      "enum": ["none", "eslint"],
+      "x-priority": "important"
     },
     "unitTestRunner": {
-      "type": "string",
-      "enum": ["jest", "none"],
       "description": "Test runner to use for unit tests.",
-      "default": "jest"
+      "type": "string",
+      "enum": ["none", "jest", "vitest"],
+      "x-priority": "important"
     },
     "tags": {
       "type": "string",
@@ -98,7 +92,11 @@
       "type": "boolean",
       "description": "Generates a boilerplate for publishing the plugin to npm.",
       "default": false
+    },
+    "useProjectJson": {
+      "type": "boolean",
+      "description": "Use a `project.json` configuration file instead of inlining the Nx configuration in the `package.json` file."
     }
   },
-  "required": ["name"]
+  "required": ["directory"]
 }

package/src/generators/plugin/utils/normalize-schema.d.ts

@@ -1,13 +1,19 @@
-import { Tree } from '@nx/devkit';
-import { Schema } from '../schema';
+import { type Tree } from '@nx/devkit';
+import type { LinterType } from '@nx/eslint';
+import type { Schema } from '../schema';
 export interface NormalizedSchema extends Schema {
-    name: string;
+    projectName: string;
     fileName: string;
     projectRoot: string;
     projectDirectory: string;
     parsedTags: string[];
-    npmPackageName: string;
+    importPath: string;
     bundler: 'swc' | 'tsc';
     publishable: boolean;
+    unitTestRunner: 'jest' | 'vitest' | 'none';
+    linter: LinterType;
+    useProjectJson: boolean;
+    addPlugin: boolean;
+    isTsSolutionSetup: boolean;
 }
 export declare function normalizeOptions(host: Tree, options: Schema): Promise<NormalizedSchema>;

package/src/generators/plugin/utils/normalize-schema.js

@@ -3,29 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeOptions = normalizeOptions;
 const devkit_1 = require("@nx/devkit");
 const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
+const generator_prompts_1 = require("@nx/js/src/utils/generator-prompts");
+const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
 async function normalizeOptions(host, options) {
-    const { projectName, projectRoot, importPath: npmPackageName, projectNameAndRootFormat, } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(host, {
+    const linter = await (0, generator_prompts_1.normalizeLinterOption)(host, options.linter);
+    const unitTestRunner = await (0, generator_prompts_1.normalizeUnitTestRunnerOption)(host, options.unitTestRunner, ['jest', 'vitest']);
+    const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(host);
+    const nxJson = (0, devkit_1.readNxJson)(host);
+    const addPlugin = options.addPlugin ??
+        (isTsSolutionSetup &&
+            process.env.NX_ADD_PLUGINS !== 'false' &&
+            nxJson.useInferencePlugins !== false);
+    await (0, project_name_and_root_utils_1.ensureRootProjectName)(options, 'library');
+    const { projectName, projectRoot, importPath } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(host, {
         name: options.name,
         projectType: 'library',
         directory: options.directory,
         importPath: options.importPath,
-        projectNameAndRootFormat: options.projectNameAndRootFormat,
         rootProject: options.rootProject,
-        callingGenerator: '@nx/plugin:plugin',
     });
-    options.projectNameAndRootFormat = projectNameAndRootFormat;
     options.rootProject = projectRoot === '.';
-    let projectDirectory = projectRoot;
-    if (options.projectNameAndRootFormat === 'derived') {
-        let { layoutDirectory } = (0, devkit_1.extractLayoutDirectory)(options.directory);
-        if (!layoutDirectory) {
-            const { libsDir } = (0, devkit_1.getWorkspaceLayout)(host);
-            layoutDirectory = libsDir;
-        }
-        if (projectRoot.startsWith(`${layoutDirectory}/`)) {
-            projectDirectory = projectRoot.replace(`${layoutDirectory}/`, '');
-        }
-    }
+    const projectDirectory = projectRoot;
     const parsedTags = options.tags
         ? options.tags.split(',').map((s) => s.trim())
         : [];
@@ -33,11 +31,17 @@ async function normalizeOptions(host, options) {
         ...options,
         bundler: options.compiler ?? 'tsc',
         fileName: projectName,
-        name: projectName,
+        projectName: isTsSolutionSetup && !options.name ? importPath : projectName,
         projectRoot,
         projectDirectory,
         parsedTags,
-        npmPackageName,
+        importPath,
         publishable: options.publishable ?? false,
+        linter,
+        unitTestRunner,
+        // We default to generate a project.json file if the new setup is not being used
+        useProjectJson: options.useProjectJson ?? !isTsSolutionSetup,
+        addPlugin,
+        isTsSolutionSetup,
     };
 }

package/src/generators/preset/generator.d.ts

@@ -1,3 +1,5 @@
-import { GeneratorCallback, Tree } from '@nx/devkit';
-import { PresetGeneratorSchema } from './schema';
-export default function (tree: Tree, options: PresetGeneratorSchema): Promise<GeneratorCallback>;
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+import type { PresetGeneratorSchema } from './schema';
+export declare function presetGenerator(tree: Tree, rawOptions: PresetGeneratorSchema): Promise<GeneratorCallback>;
+export declare function presetGeneratorInternal(tree: Tree, rawOptions: PresetGeneratorSchema): Promise<GeneratorCallback>;
+export default presetGenerator;