@nx/plugin 0.0.0-pr-22179-271588f

package/src/generators/create-package/create-package.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPackageGeneratorInternal = exports.createPackageGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const versions_1 = require("nx/src/utils/versions");
+const generator_1 = require("../generator/generator");
+const normalize_schema_1 = require("./utils/normalize-schema");
+const has_generator_1 = require("../../utils/has-generator");
+const path_1 = require("path");
+async function createPackageGenerator(host, schema) {
+    return await createPackageGeneratorInternal(host, {
+        projectNameAndRootFormat: 'derived',
+        ...schema,
+    });
+}
+exports.createPackageGenerator = createPackageGenerator;
+async function createPackageGeneratorInternal(host, schema) {
+    const tasks = [];
+    const options = await (0, normalize_schema_1.normalizeSchema)(host, schema);
+    const pluginPackageName = await addPresetGenerator(host, options);
+    const installTask = (0, devkit_1.addDependenciesToPackageJson)(host, {
+        'create-nx-workspace': versions_1.nxVersion,
+    }, {});
+    tasks.push(installTask);
+    await createCliPackage(host, options, pluginPackageName);
+    if (options.e2eProject) {
+        addE2eProject(host, options);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(host);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.createPackageGeneratorInternal = createPackageGeneratorInternal;
+/**
+ * Add a preset generator to the plugin if it doesn't exist
+ * @param host
+ * @param schema
+ * @returns package name of the plugin
+ */
+async function addPresetGenerator(host, schema) {
+    const { root: projectRoot } = (0, devkit_1.readProjectConfiguration)(host, schema.project);
+    if (!(0, has_generator_1.hasGenerator)(host, schema.project, 'preset')) {
+        await (0, generator_1.default)(host, {
+            name: 'preset',
+            directory: (0, path_1.join)(projectRoot, 'src/generators/preset'),
+            unitTestRunner: schema.unitTestRunner,
+            skipFormat: true,
+            nameAndDirectoryFormat: 'as-provided',
+        });
+    }
+    return (0, devkit_1.readJson)(host, (0, devkit_1.joinPathFragments)(projectRoot, 'package.json'))?.name;
+}
+async function createCliPackage(host, options, pluginPackageName) {
+    await (0, js_1.libraryGenerator)(host, {
+        ...options,
+        rootProject: false,
+        config: 'project',
+        publishable: true,
+        bundler: options.bundler,
+        importPath: options.name,
+        skipFormat: true,
+        skipTsConfig: true,
+    });
+    host.delete((0, devkit_1.joinPathFragments)(options.projectRoot, 'src'));
+    // Add the bin entry to the package.json
+    (0, devkit_1.updateJson)(host, (0, devkit_1.joinPathFragments)(options.projectRoot, 'package.json'), (packageJson) => {
+        packageJson.bin = {
+            [options.name]: './bin/index.js',
+        };
+        packageJson.dependencies = {
+            'create-nx-workspace': versions_1.nxVersion,
+        };
+        return packageJson;
+    });
+    // update project build target to use the bin entry
+    const projectConfiguration = (0, devkit_1.readProjectConfiguration)(host, options.projectName);
+    projectConfiguration.sourceRoot = (0, devkit_1.joinPathFragments)(options.projectRoot, 'bin');
+    projectConfiguration.targets.build.options.main = (0, devkit_1.joinPathFragments)(options.projectRoot, 'bin/index.ts');
+    projectConfiguration.implicitDependencies = [options.project];
+    (0, devkit_1.updateProjectConfiguration)(host, options.projectName, projectConfiguration);
+    // Add bin files to tsconfg.lib.json
+    (0, devkit_1.updateJson)(host, (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.lib.json'), (tsConfig) => {
+        tsConfig.include.push('bin/**/*.ts');
+        return tsConfig;
+    });
+    (0, devkit_1.generateFiles)(host, (0, devkit_1.joinPathFragments)(__dirname, './files/create-framework-package'), options.projectRoot, {
+        ...options,
+        preset: pluginPackageName,
+        tmpl: '',
+    });
+}
+/**
+ * Add a test file to plugin e2e project
+ * @param host
+ * @param options
+ * @returns
+ */
+function addE2eProject(host, options) {
+    const e2eProjectConfiguration = (0, devkit_1.readProjectConfiguration)(host, options.e2eProject);
+    const projectConfiguration = (0, devkit_1.readProjectConfiguration)(host, options.project);
+    const { name: pluginPackageName } = (0, devkit_1.readJson)(host, (0, path_1.join)(projectConfiguration.root, 'package.json'));
+    (0, devkit_1.generateFiles)(host, (0, devkit_1.joinPathFragments)(__dirname, './files/e2e'), e2eProjectConfiguration.sourceRoot, {
+        pluginName: options.project,
+        cliName: options.name,
+        packageManagerCommands: (0, devkit_1.getPackageManagerCommand)('npm'),
+        pluginPackageName,
+        tmpl: '',
+    });
+}
+exports.default = createPackageGenerator;

package/src/generators/create-package/files/create-framework-package/bin/index.ts__tmpl__

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+import { createWorkspace } from 'create-nx-workspace';
+
+async function main() {
+  const name = process.argv[2]; // TODO: use libraries like yargs or enquirer to set your workspace name
+  if (!name) {
+    throw new Error('Please provide a name for the workspace');
+  }
+
+  console.log(`Creating the workspace: ${name}`);
+
+  // This assumes "<%= preset %>" and "<%= projectName %>" are at the same version
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const presetVersion = require('../package.json').version,
+
+  // TODO: update below to customize the workspace
+  const { directory } = await createWorkspace(`<%= preset %>@${presetVersion}`, {
+    name,
+    nxCloud: 'skip',
+    packageManager: 'npm',
+  });
+
+  console.log(`Successfully created the workspace: ${directory}.`);
+}
+
+main();

package/src/generators/create-package/files/e2e/__cliName__.spec.ts__tmpl__

@@ -0,0 +1,56 @@
+import { execSync } from 'child_process';
+import { join, dirname } from 'path';
+import { mkdirSync, rmSync } from 'fs';
+
+describe('<%= cliName %>', () => {
+  let projectDirectory: string;
+
+  afterAll(() => {
+    // Cleanup the test project
+    rmSync(projectDirectory, {
+      recursive: true,
+      force: true,
+    });
+  });
+
+
+  it('should be installed', () => {
+    projectDirectory = createTestProject();
+
+    // npm ls will fail if the package is not installed properly
+    execSync('<%= packageManagerCommands.list %> <%= pluginPackageName %>', {
+      cwd: projectDirectory,
+      stdio: 'inherit',
+    });
+  });
+});
+
+/**
+ * Creates a test project with create-nx-workspace and installs the plugin
+ * @returns The directory where the test project was created
+ */
+function createTestProject(extraArgs = '') {
+  const projectName = 'test-project';
+  const projectDirectory = join(process.cwd(), 'tmp', projectName);
+
+  // Ensure projectDirectory is empty
+  rmSync(projectDirectory, {
+    recursive: true,
+    force: true,
+  });
+  mkdirSync(dirname(projectDirectory), {
+    recursive: true,
+  });
+
+  execSync(
+    `<%= packageManagerCommands.exec %> --yes <%= cliName %>@e2e ${projectName} ${extraArgs}`,
+    {
+      cwd: dirname(projectDirectory),
+      stdio: 'inherit',
+      env: process.env,
+    }
+  );
+  console.log(`Created test project in "${projectDirectory}"`);
+
+  return projectDirectory;
+}

package/src/generators/create-package/schema.d.ts

@@ -0,0 +1,19 @@
+import type { ProjectNameAndRootFormat } from '@nx/devkit/src/generators/project-name-and-root-utils';
+import type { Linter } from '@nx/eslint';
+
+export interface CreatePackageSchema {
+  name: string;
+  project: string;
+
+  // options to create cli package, passed to js library generator
+  directory?: string;
+  projectNameAndRootFormat?: ProjectNameAndRootFormat;
+  skipFormat: boolean;
+  tags?: string;
+  unitTestRunner: 'jest' | 'none';
+  linter: Linter;
+  compiler: 'swc' | 'tsc';
+
+  // options to create e2e project, passed to e2e project generator
+  e2eProject?: string;
+}

package/src/generators/create-package/schema.json

@@ -0,0 +1,79 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "NxPluginCreatePackage",
+  "title": "Create a framework package",
+  "description": "Create a framework package that uses Nx CLI.",
+  "examplesFile": "../../../docs/generators/create-package-examples.md",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The package name of cli, e.g. `create-framework-package`. Note this must be a valid NPM name to be published.",
+      "pattern": "create-.+|^@.+/create(?:-.+)?",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-priority": "important"
+    },
+    "project": {
+      "type": "string",
+      "description": "The name of the generator project.",
+      "alias": "p",
+      "$default": {
+        "$source": "projectName"
+      },
+      "x-prompt": "What is the name of the project for the generator?",
+      "x-priority": "important"
+    },
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["jest", "none"],
+      "description": "Test runner to use for unit tests.",
+      "default": "jest"
+    },
+    "directory": {
+      "type": "string",
+      "description": "A directory where the app is placed."
+    },
+    "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"]
+    },
+    "linter": {
+      "description": "The tool to use for running lint checks.",
+      "type": "string",
+      "enum": ["eslint"],
+      "default": "eslint"
+    },
+    "tags": {
+      "type": "string",
+      "description": "Add tags to the library (used for linting).",
+      "alias": "t"
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "compiler": {
+      "type": "string",
+      "enum": ["tsc", "swc"],
+      "default": "tsc",
+      "description": "The compiler used by the build and test targets."
+    },
+    "e2eProject": {
+      "type": "string",
+      "description": "The name of the e2e project.",
+      "alias": "p",
+      "$default": {
+        "$source": "projectName"
+      },
+      "x-prompt": "What is the name of the e2e project?"
+    }
+  },
+  "required": ["name", "project"]
+}

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

@@ -0,0 +1,8 @@
+import { Tree } from '@nx/devkit';
+import { CreatePackageSchema } from '../schema';
+export interface NormalizedSchema extends CreatePackageSchema {
+    bundler: 'swc' | 'tsc';
+    projectName: string;
+    projectRoot: string;
+}
+export declare function normalizeSchema(host: Tree, schema: CreatePackageSchema): Promise<NormalizedSchema>;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSchema = void 0;
+const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
+async function normalizeSchema(host, schema) {
+    const { projectName, names: projectNames, projectRoot, projectNameAndRootFormat, } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(host, {
+        name: schema.name,
+        projectType: 'library',
+        directory: schema.directory,
+        projectNameAndRootFormat: schema.projectNameAndRootFormat,
+        callingGenerator: '@nx/plugin:create-package',
+    });
+    schema.projectNameAndRootFormat = projectNameAndRootFormat;
+    return {
+        ...schema,
+        bundler: schema.compiler ?? 'tsc',
+        projectName,
+        projectRoot,
+        name: projectNames.projectSimpleName,
+    };
+}
+exports.normalizeSchema = normalizeSchema;

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

@@ -0,0 +1,6 @@
+import type { Tree } from '@nx/devkit';
+import { GeneratorCallback } from '@nx/devkit';
+import type { Schema } from './schema';
+export declare function e2eProjectGenerator(host: Tree, schema: Schema): Promise<GeneratorCallback>;
+export declare function e2eProjectGeneratorInternal(host: Tree, schema: Schema): Promise<GeneratorCallback>;
+export default e2eProjectGenerator;

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

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.e2eProjectGeneratorInternal = exports.e2eProjectGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
+const jest_1 = require("@nx/jest");
+const js_1 = require("@nx/js");
+const generator_1 = require("@nx/js/src/generators/setup-verdaccio/generator");
+const add_local_registry_scripts_1 = require("@nx/js/src/utils/add-local-registry-scripts");
+const eslint_1 = require("@nx/eslint");
+const path_1 = require("path");
+async function normalizeOptions(host, options) {
+    const projectName = options.rootProject ? 'e2e' : `${options.pluginName}-e2e`;
+    const nxJson = (0, devkit_1.readNxJson)(host);
+    const addPlugin = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    options.addPlugin ??= addPlugin;
+    let projectRoot;
+    if (options.projectNameAndRootFormat === 'as-provided') {
+        const projectNameAndRootOptions = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(host, {
+            name: projectName,
+            projectType: 'application',
+            directory: options.rootProject || !options.projectDirectory
+                ? projectName
+                : `${options.projectDirectory}-e2e`,
+            projectNameAndRootFormat: `as-provided`,
+            callingGenerator: '@nx/plugin:e2e-project',
+        });
+        projectRoot = projectNameAndRootOptions.projectRoot;
+    }
+    else {
+        const { layoutDirectory, projectDirectory } = (0, devkit_1.extractLayoutDirectory)(options.projectDirectory);
+        const { appsDir: defaultAppsDir } = (0, devkit_1.getWorkspaceLayout)(host);
+        const appsDir = layoutDirectory ?? defaultAppsDir;
+        projectRoot = options.rootProject
+            ? projectName
+            : projectDirectory
+                ? (0, devkit_1.joinPathFragments)(appsDir, `${projectDirectory}-e2e`)
+                : (0, devkit_1.joinPathFragments)(appsDir, projectName);
+    }
+    const pluginPropertyName = (0, devkit_1.names)(options.pluginName).propertyName;
+    return {
+        ...options,
+        projectName,
+        linter: options.linter ?? eslint_1.Linter.EsLint,
+        pluginPropertyName,
+        projectRoot,
+    };
+}
+function validatePlugin(host, pluginName) {
+    try {
+        (0, devkit_1.readProjectConfiguration)(host, pluginName);
+    }
+    catch {
+        throw new Error(`Project name "${pluginName}" doesn't not exist.`);
+    }
+}
+function addFiles(host, options) {
+    const projectConfiguration = (0, devkit_1.readProjectConfiguration)(host, options.pluginName);
+    const { name: pluginPackageName } = (0, devkit_1.readJson)(host, (0, path_1.join)(projectConfiguration.root, 'package.json'));
+    (0, devkit_1.generateFiles)(host, (0, path_1.join)(__dirname, './files'), options.projectRoot, {
+        ...options,
+        tmpl: '',
+        rootTsConfigPath: (0, js_1.getRelativePathToRootTsConfig)(host, options.projectRoot),
+        packageManagerCommands: (0, devkit_1.getPackageManagerCommand)('npm'),
+        pluginPackageName,
+    });
+}
+async function addJest(host, options) {
+    (0, devkit_1.addProjectConfiguration)(host, options.projectName, {
+        root: options.projectRoot,
+        projectType: 'application',
+        sourceRoot: `${options.projectRoot}/src`,
+        targets: {},
+        implicitDependencies: [options.pluginName],
+    });
+    const jestTask = await (0, jest_1.configurationGenerator)(host, {
+        project: options.projectName,
+        targetName: 'e2e',
+        setupFile: 'none',
+        supportTsx: false,
+        skipSerializers: true,
+        skipFormat: true,
+        addPlugin: options.addPlugin,
+    });
+    const { startLocalRegistryPath, stopLocalRegistryPath } = (0, add_local_registry_scripts_1.addLocalRegistryScripts)(host);
+    (0, jest_1.addPropertyToJestConfig)(host, (0, path_1.join)(options.projectRoot, 'jest.config.ts'), 'globalSetup', (0, path_1.join)((0, devkit_1.offsetFromRoot)(options.projectRoot), startLocalRegistryPath));
+    (0, jest_1.addPropertyToJestConfig)(host, (0, path_1.join)(options.projectRoot, 'jest.config.ts'), 'globalTeardown', (0, path_1.join)((0, devkit_1.offsetFromRoot)(options.projectRoot), stopLocalRegistryPath));
+    const project = (0, devkit_1.readProjectConfiguration)(host, options.projectName);
+    const e2eTarget = project.targets.e2e;
+    project.targets.e2e = {
+        ...e2eTarget,
+        dependsOn: [`^build`],
+        options: {
+            ...e2eTarget.options,
+            runInBand: true,
+        },
+    };
+    (0, devkit_1.updateProjectConfiguration)(host, options.projectName, project);
+    return jestTask;
+}
+async function addLintingToApplication(tree, options) {
+    const lintTask = await (0, eslint_1.lintProjectGenerator)(tree, {
+        linter: options.linter,
+        project: options.projectName,
+        tsConfigPaths: [
+            (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.app.json'),
+        ],
+        unitTestRunner: 'jest',
+        skipFormat: true,
+        setParserOptionsProject: false,
+        addPlugin: options.addPlugin,
+    });
+    return lintTask;
+}
+async function e2eProjectGenerator(host, schema) {
+    return await e2eProjectGeneratorInternal(host, {
+        addPlugin: false,
+        projectNameAndRootFormat: 'derived',
+        ...schema,
+    });
+}
+exports.e2eProjectGenerator = e2eProjectGenerator;
+async function e2eProjectGeneratorInternal(host, schema) {
+    const tasks = [];
+    validatePlugin(host, schema.pluginName);
+    const options = await normalizeOptions(host, schema);
+    addFiles(host, options);
+    tasks.push(await (0, generator_1.setupVerdaccio)(host, {
+        skipFormat: true,
+    }));
+    tasks.push(await addJest(host, options));
+    if (options.linter !== eslint_1.Linter.None) {
+        tasks.push(await addLintingToApplication(host, {
+            ...options,
+        }));
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(host);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.e2eProjectGeneratorInternal = e2eProjectGeneratorInternal;
+exports.default = e2eProjectGenerator;

package/src/generators/e2e-project/files/src/__pluginName__.spec.ts__tmpl__

@@ -0,0 +1,66 @@
+import { execSync } from 'child_process';
+import { join, dirname } from 'path';
+import { mkdirSync, rmSync } from 'fs';
+
+describe('<%= pluginName %>', () => {
+  let projectDirectory: string;
+
+  beforeAll(() => {
+    projectDirectory = createTestProject();
+
+    // The plugin has been built and published to a local registry in the jest globalSetup
+    // Install the plugin built with the latest source code into the test repo
+    execSync(`<%= packageManagerCommands.install %> <%= pluginPackageName %>@e2e`, {
+      cwd: projectDirectory,
+      stdio: 'inherit',
+      env: process.env,
+    });
+  });
+
+  afterAll(() => {
+    // Cleanup the test project
+    rmSync(projectDirectory, {
+      recursive: true,
+      force: true,
+    });
+  });
+
+
+  it('should be installed', () => {
+    // npm ls will fail if the package is not installed properly
+    execSync('<%= packageManagerCommands.list %> <%= pluginPackageName %>', {
+      cwd: projectDirectory,
+      stdio: 'inherit',
+    });
+  });
+});
+
+/**
+ * Creates a test project with create-nx-workspace and installs the plugin
+ * @returns The directory where the test project was created
+ */
+function createTestProject() {
+  const projectName = 'test-project';
+  const projectDirectory = join(process.cwd(), 'tmp', projectName);
+
+  // Ensure projectDirectory is empty
+  rmSync(projectDirectory, {
+    recursive: true,
+    force: true,
+  });
+  mkdirSync(dirname(projectDirectory), {
+    recursive: true,
+  });
+
+  execSync(
+    `<%= packageManagerCommands.exec %> --yes create-nx-workspace@latest ${projectName} --preset apps --nxCloud=skip --no-interactive`,
+    {
+      cwd: dirname(projectDirectory),
+      stdio: 'inherit',
+      env: process.env,
+    }
+  );
+  console.log(`Created test project in "${projectDirectory}"`);
+
+  return projectDirectory;
+}

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

@@ -0,0 +1,6 @@
+{
+  "extends": "<%= rootTsConfigPath %>",
+  "files": [],
+  "include": [],
+  "references": []
+}

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

@@ -0,0 +1,15 @@
+import type { ProjectNameAndRootFormat } from '@nx/devkit/src/generators/project-name-and-root-utils';
+import type { Linter } from '@nx/eslint';
+
+export interface Schema {
+  pluginName: string;
+  npmPackageName: string;
+  projectDirectory?: string;
+  projectNameAndRootFormat?: ProjectNameAndRootFormat;
+  pluginOutputPath?: string;
+  jestConfig?: string;
+  linter?: Linter;
+  skipFormat?: boolean;
+  rootProject?: boolean;
+  addPlugin?: boolean;
+}

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

@@ -0,0 +1,57 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "NxPluginE2E",
+  "title": "Create an E2E app for a Nx Plugin",
+  "description": "Create an E2E app for a Nx Plugin.",
+  "examplesFile": "../../../docs/generators/e2e-project-examples.md",
+  "type": "object",
+  "properties": {
+    "pluginName": {
+      "type": "string",
+      "description": "the project name of the plugin to be tested.",
+      "x-priority": "important"
+    },
+    "npmPackageName": {
+      "type": "string",
+      "description": "the package name of the plugin as it would be published to NPM.",
+      "x-priority": "important"
+    },
+    "projectDirectory": {
+      "type": "string",
+      "description": "the directory where the plugin is placed."
+    },
+    "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"]
+    },
+    "pluginOutputPath": {
+      "type": "string",
+      "description": "the output path of the plugin after it builds.",
+      "x-priority": "important"
+    },
+    "jestConfig": {
+      "type": "string",
+      "description": "Jest config file."
+    },
+    "linter": {
+      "description": "The tool to use for running lint checks.",
+      "type": "string",
+      "enum": ["eslint", "none"],
+      "default": "eslint"
+    },
+    "minimal": {
+      "type": "boolean",
+      "description": "Generate the e2e project with a minimal setup. This would involve not generating tests for a default executor and generator.",
+      "default": false
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    }
+  },
+  "required": ["pluginName", "npmPackageName"]
+}

package/src/generators/executor/executor.d.ts

@@ -0,0 +1,6 @@
+import type { Tree } from '@nx/devkit';
+import type { Schema } from './schema';
+export declare function createExecutorsJson(host: Tree, projectRoot: string, projectName: string, skipLintChecks?: boolean): Promise<void>;
+export declare function executorGenerator(tree: Tree, rawOptions: Schema): Promise<void>;
+export declare function executorGeneratorInternal(host: Tree, schema: Schema): Promise<void>;
+export default executorGenerator;