@nx/plugin 20.1.0 → 20.2.0-beta.1

package/src/generators/generator/generator.js

@@ -3,50 +3,53 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createGeneratorsJson = createGeneratorsJson;
 exports.generatorGenerator = generatorGenerator;
 const devkit_1 = require("@nx/devkit");
+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 has_generator_1 = require("../../utils/has-generator");
-const generator_1 = require("../lint-checks/generator");
+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 path_1 = require("path");
+const generator_1 = require("../lint-checks/generator");
 async function normalizeOptions(tree, options) {
-    const { project, fileName, artifactName, filePath, directory } = await (0, artifact_name_and_directory_utils_1.determineArtifactNameAndDirectoryOptions)(tree, {
-        name: options.name,
+    const { artifactName: name, directory, fileName, project, } = await (0, artifact_name_and_directory_utils_1.determineArtifactNameAndDirectoryOptions)(tree, {
         path: options.path,
-        fileName: 'generator',
+        name: options.name,
     });
-    const { className, propertyName } = (0, devkit_1.names)(artifactName);
+    const { className, propertyName } = (0, devkit_1.names)(name);
     const { root: projectRoot, sourceRoot: projectSourceRoot } = (0, devkit_1.readProjectConfiguration)(tree, project);
     let description;
     if (options.description) {
         description = options.description;
     }
     else {
-        description = `${options.name} generator`;
+        description = `${name} generator`;
     }
     return {
         ...options,
         directory,
         project,
+        name,
         fileName,
         className,
         propertyName,
         description,
         projectRoot,
         projectSourceRoot,
+        isTsSolutionSetup: (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree),
     };
 }
 function addFiles(host, options) {
-    const indexPath = (0, path_1.join)(options.path, 'files/src/index.ts.template');
+    const indexPath = (0, node_path_1.join)(options.directory, 'files/src/index.ts.template');
     if (!host.exists(indexPath)) {
         host.write(indexPath, 'const variable = "<%= name %>";');
     }
-    (0, devkit_1.generateFiles)(host, (0, path_1.join)(__dirname, './files/generator'), options.path, {
+    (0, devkit_1.generateFiles)(host, (0, node_path_1.join)(__dirname, './files/generator'), options.directory, {
         ...options,
         generatorFnName: `${options.propertyName}Generator`,
         schemaInterfaceName: `${options.className}GeneratorSchema`,
     });
     if (options.unitTestRunner === 'none') {
-        host.delete((0, path_1.join)(options.path, `generator.spec.ts`));
+        host.delete((0, node_path_1.join)(options.directory, `${options.fileName}.spec.ts`));
     }
 }
 async function createGeneratorsJson(host, projectRoot, projectName, skipLintChecks, skipFormat) {
@@ -75,6 +78,14 @@ async function updateGeneratorJson(host, options) {
     }
     if (!host.exists(generatorsPath)) {
         await createGeneratorsJson(host, options.projectRoot, options.project, options.skipLintChecks, options.skipFormat);
+        if (options.isTsSolutionSetup) {
+            (0, devkit_1.updateJson)(host, (0, devkit_1.joinPathFragments)(options.projectRoot, 'package.json'), (json) => {
+                const filesSet = new Set(json.files ?? ['dist', '!**/*.tsbuildinfo']);
+                filesSet.add('generators.json');
+                json.files = [...filesSet];
+                return json;
+            });
+        }
     }
     // add dependencies
     (0, devkit_1.updateJson)(host, (0, devkit_1.joinPathFragments)(options.projectRoot, 'package.json'), (json) => {
@@ -87,9 +98,10 @@ async function updateGeneratorJson(host, options) {
     (0, devkit_1.updateJson)(host, generatorsPath, (json) => {
         let generators = json.generators ?? json.schematics;
         generators = generators || {};
+        const dir = (0, paths_1.getArtifactMetadataDirectory)(host, options.project, options.directory, options.isTsSolutionSetup);
         generators[options.name] = {
-            factory: `./${(0, devkit_1.joinPathFragments)((0, path_1.relative)(options.projectRoot, options.path), 'generator')}`,
-            schema: `./${(0, devkit_1.joinPathFragments)((0, path_1.relative)(options.projectRoot, options.path), 'schema.json')}`,
+            factory: `${dir}/${options.fileName}`,
+            schema: `${dir}/schema.json`,
             description: options.description,
         };
         // @todo(v17): Remove this, prop is defunct.

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

@@ -1,4 +1,4 @@
-import type { Tree } from '@nx/devkit';
+import { type Tree } from '@nx/devkit';
 import type { Schema } from './schema';
 export declare function migrationGenerator(host: Tree, schema: Schema): Promise<void>;
 export default migrationGenerator;

package/src/generators/migration/migration.js

@@ -2,42 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.migrationGenerator = migrationGenerator;
 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, {
-        name: name,
+    const { artifactName: name, directory, fileName, project, } = await (0, artifact_name_and_directory_utils_1.determineArtifactNameAndDirectoryOptions)(tree, {
         path: options.path,
-        fileName: name,
+        name: options.name,
     });
     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,
         directory,
+        fileName,
         project,
-        name: artifactName,
+        name,
         description,
         projectRoot,
         projectSourceRoot,
+        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.path, {
+    (0, devkit_1.generateFiles)(host, (0, node_path_1.join)(__dirname, 'files/migration'), options.directory, {
         ...options,
         tmpl: '',
     });
@@ -49,10 +42,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.path), options.name)}`,
+        implementation: `${dir}/${options.fileName}`,
     };
     migrations.generators = generators;
     if (options.packageJsonUpdates) {
@@ -68,10 +62,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]) {
@@ -79,9 +80,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,
@@ -91,6 +93,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 &&
@@ -109,10 +114,9 @@ function updateProjectConfig(host, options) {
 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/plugin/plugin.d.ts

@@ -1,4 +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

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pluginGenerator = pluginGenerator;
+exports.pluginGeneratorInternal = pluginGeneratorInternal;
 const devkit_1 = require("@nx/devkit");
+const eslint_1 = require("@nx/eslint");
 const js_1 = require("@nx/js");
+const package_manager_workspaces_1 = require("@nx/js/src/utils/package-manager-workspaces");
 const add_swc_dependencies_1 = require("@nx/js/src/utils/swc/add-swc-dependencies");
-const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
-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`));
@@ -23,36 +23,31 @@ async function addFiles(host, options) {
 function updatePluginConfig(host, options) {
     const project = (0, devkit_1.readProjectConfiguration)(host, options.name);
     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;
+            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 ?? []),
         ];
+        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.name, project);
     }
 }
-async function pluginGenerator(host, schema) {
-    (0, ts_solution_setup_1.assertNotUsingTsSolutionSetup)(host, 'plugin', 'plugin');
+async function pluginGenerator(tree, schema) {
+    return await pluginGeneratorInternal(tree, {
+        useProjectJson: true,
+        addPlugin: false,
+        ...schema,
+    });
+}
+async function pluginGeneratorInternal(host, schema) {
     const options = await (0, normalize_schema_1.normalizeOptions)(host, schema);
     const tasks = [];
     tasks.push(await (0, js_1.libraryGenerator)(host, {
@@ -63,7 +58,13 @@ async function pluginGenerator(host, schema) {
         bundler: options.bundler,
         publishable: options.publishable,
         importPath: options.npmPackageName,
+        linter: options.linter,
+        unitTestRunner: options.unitTestRunner,
+        useProjectJson: options.useProjectJson,
+        addPlugin: options.addPlugin,
         skipFormat: true,
+        skipWorkspacesWarning: true,
+        useTscExecutor: true,
     }));
     if (options.bundler === 'tsc') {
         tasks.push((0, add_tslib_dependencies_1.addTsLibDependencies)(host));
@@ -78,7 +79,7 @@ async function pluginGenerator(host, schema) {
     // 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') {
@@ -89,6 +90,10 @@ async function pluginGenerator(host, schema) {
             npmPackageName: options.npmPackageName,
             skipFormat: true,
             rootProject: options.rootProject,
+            linter: options.linter,
+            useProjectJson: options.useProjectJson,
+            addPlugin: options.addPlugin,
+            skipWorkspacesWarning: true,
         }));
     }
     if (options.linter === eslint_1.Linter.EsLint && !options.skipLintChecks) {
@@ -97,6 +102,12 @@ async function pluginGenerator(host, schema) {
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(host);
     }
+    if (options.isTsSolutionSetup) {
+        const projectPackageManagerWorkspaceState = (0, package_manager_workspaces_1.getProjectPackageManagerWorkspaceState)(host, options.projectRoot);
+        if (projectPackageManagerWorkspaceState !== 'included') {
+            tasks.push((0, package_manager_workspaces_1.getProjectPackageManagerWorkspaceStateWarningTask)(projectPackageManagerWorkspaceState, host.root));
+        }
+    }
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
 exports.default = pluginGenerator;

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

@@ -9,10 +9,12 @@ export interface Schema {
   skipLintChecks?: boolean; // default is false
   e2eTestRunner?: 'jest' | 'none';
   tags?: string;
-  unitTestRunner: 'jest' | 'none';
-  linter: Linter | LinterType;
+  unitTestRunner?: 'jest' | '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

@@ -34,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"],
+      "x-priority": "important"
     },
     "tags": {
       "type": "string",
@@ -92,6 +92,10 @@
       "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": ["directory"]

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

@@ -1,5 +1,6 @@
-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;
     fileName: string;
@@ -9,5 +10,10 @@ export interface NormalizedSchema extends Schema {
     npmPackageName: string;
     bundler: 'swc' | 'tsc';
     publishable: boolean;
+    unitTestRunner: 'jest' | '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

@@ -1,8 +1,19 @@
 "use strict";
 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 linter = await (0, generator_prompts_1.normalizeLinterOption)(host, options.linter);
+    const unitTestRunner = await (0, generator_prompts_1.normalizeUnitTestRunnerOption)(host, options.unitTestRunner, ['jest']);
+    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.ensureProjectName)(host, options, 'application');
     const { projectName, projectRoot, importPath: npmPackageName, } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(host, {
         name: options.name,
@@ -26,5 +37,11 @@ async function normalizeOptions(host, options) {
         parsedTags,
         npmPackageName,
         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;

package/src/generators/preset/generator.js

@@ -1,24 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
+exports.presetGenerator = presetGenerator;
+exports.presetGeneratorInternal = presetGeneratorInternal;
 const devkit_1 = require("@nx/devkit");
-const eslint_1 = require("@nx/eslint");
 const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
-const plugin_1 = require("../plugin/plugin");
 const create_package_1 = require("../create-package/create-package");
-async function default_1(tree, options) {
-    (0, ts_solution_setup_1.assertNotUsingTsSolutionSetup)(tree, 'plugin', 'preset');
+const plugin_1 = require("../plugin/plugin");
+async function presetGenerator(tree, rawOptions) {
+    return await presetGeneratorInternal(tree, {
+        addPlugin: false,
+        useProjectJson: true,
+        ...rawOptions,
+    });
+}
+async function presetGeneratorInternal(tree, rawOptions) {
     const tasks = [];
-    const pluginProjectName = (0, devkit_1.names)(options.pluginName.includes('/')
-        ? options.pluginName.split('/')[1]
-        : options.pluginName).fileName;
-    options.createPackageName =
-        options.createPackageName === 'false' // for command line in e2e, it is passed as a string
-            ? undefined
-            : options.createPackageName;
+    const options = normalizeOptions(tree, rawOptions);
     const pluginTask = await (0, plugin_1.pluginGenerator)(tree, {
         compiler: 'tsc',
-        linter: eslint_1.Linter.EsLint,
+        linter: 'eslint',
         skipFormat: true,
         unitTestRunner: 'jest',
         importPath: options.pluginName,
@@ -26,23 +26,27 @@ async function default_1(tree, options) {
         publishable: true,
         // when creating a CLI package, the plugin will be in the packages folder
         directory: options.createPackageName && options.createPackageName !== 'false'
-            ? `packages/${pluginProjectName}`
-            : pluginProjectName,
+            ? `packages/${options.pluginName}`
+            : options.pluginName,
         rootProject: options.createPackageName ? false : true,
+        useProjectJson: options.useProjectJson,
+        addPlugin: options.addPlugin,
     });
     tasks.push(pluginTask);
     moveNxPluginToDevDeps(tree);
     if (options.createPackageName) {
         const e2eProject = `${options.pluginName}-e2e`;
-        const cliTask = await (0, create_package_1.default)(tree, {
+        const cliTask = await (0, create_package_1.createPackageGenerator)(tree, {
             directory: `packages/${options.createPackageName}`,
             name: options.createPackageName,
             e2eProject: e2eProject,
             project: options.pluginName,
             skipFormat: true,
             unitTestRunner: 'jest',
-            linter: eslint_1.Linter.EsLint,
+            linter: 'eslint',
             compiler: 'tsc',
+            useProjectJson: options.useProjectJson,
+            addPlugin: options.addPlugin,
         });
         tasks.push(cliTask);
     }
@@ -51,9 +55,31 @@ async function default_1(tree, options) {
 }
 function moveNxPluginToDevDeps(tree) {
     (0, devkit_1.updateJson)(tree, 'package.json', (json) => {
-        const nxPluginEntry = json.dependencies['@nx/plugin'];
-        delete json.dependencies['@nx/plugin'];
-        json.devDependencies['@nx/plugin'] = nxPluginEntry;
+        if (json.dependencies['@nx/plugin']) {
+            const nxPluginEntry = json.dependencies['@nx/plugin'];
+            delete json.dependencies['@nx/plugin'];
+            json.devDependencies['@nx/plugin'] = nxPluginEntry;
+        }
         return json;
     });
 }
+function normalizeOptions(tree, options) {
+    const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree);
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPlugin = options.addPlugin ??
+        (isTsSolutionSetup &&
+            process.env.NX_ADD_PLUGINS !== 'false' &&
+            nxJson.useInferencePlugins !== false);
+    return {
+        ...options,
+        pluginName: (0, devkit_1.names)(options.pluginName.includes('/')
+            ? options.pluginName.split('/')[1]
+            : options.pluginName).fileName,
+        createPackageName: options.createPackageName === 'false' // for command line in e2e, it is passed as a string
+            ? undefined
+            : options.createPackageName,
+        addPlugin,
+        useProjectJson: options.useProjectJson ?? !isTsSolutionSetup,
+    };
+}
+exports.default = presetGenerator;

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

@@ -1,4 +1,13 @@
 export interface PresetGeneratorSchema {
   pluginName: string;
   createPackageName?: string;
+  useProjectJson?: boolean;
+  addPlugin?: boolean;
+}
+
+export interface NormalizedPresetGeneratorOptions
+  extends PresetGeneratorSchema {
+  createPackageName: string;
+  useProjectJson: boolean;
+  addPlugin: boolean;
 }

package/src/generators/preset/schema.json

@@ -24,6 +24,10 @@
     "createPackageName": {
       "type": "string",
       "description": "Name of package which creates a workspace"
+    },
+    "useProjectJson": {
+      "type": "boolean",
+      "description": "Use a `project.json` configuration file instead of inlining the Nx configuration in the `package.json` file."
     }
   },
   "required": ["pluginName"]

package/src/utils/paths.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function getArtifactMetadataDirectory(tree: Tree, projectName: string, sourceDirectory: string, isTsSolutionSetup: boolean): string;

package/src/utils/paths.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArtifactMetadataDirectory = getArtifactMetadataDirectory;
+const devkit_1 = require("@nx/devkit");
+const posix_1 = require("node:path/posix");
+function getArtifactMetadataDirectory(tree, projectName, sourceDirectory, isTsSolutionSetup) {
+    const project = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+    if (!isTsSolutionSetup) {
+        return `./${(0, posix_1.relative)(project.root, sourceDirectory)}`;
+    }
+    const target = Object.values(project.targets ?? {}).find((t) => t.executor === '@nx/js:tsc' || t.executor === '@nx/js:swc');
+    // the repo is using the new ts setup where the outputs are contained inside the project
+    if (target?.executor === '@nx/js:tsc') {
+        // the @nx/js:tsc executor defaults rootDir to the project root
+        return `./${(0, posix_1.join)('dist', (0, posix_1.relative)(target.options.rootDir ?? project.root, sourceDirectory))}`;
+    }
+    if (target?.executor === '@nx/js:swc') {
+        return `./${(0, posix_1.join)('dist', target.options.stripLeadingPaths
+            ? (0, posix_1.relative)((0, posix_1.dirname)(target.options.main), sourceDirectory)
+            : (0, posix_1.relative)(project.root, sourceDirectory))}`;
+    }
+    // We generate the plugin with the executors above, so we shouldn't get here
+    // unless the user manually changed the build process. In that case, we can't
+    // reliably determine the output directory because it depends on the build
+    // tool, so we'll just assume some defaults.
+    const baseDir = project.sourceRoot ??
+        (tree.exists((0, posix_1.join)(project.root, 'src'))
+            ? (0, posix_1.join)(project.root, 'src')
+            : project.root);
+    return `./${(0, posix_1.join)('dist', (0, posix_1.relative)(baseDir, sourceDirectory))}`;
+}