@nx/eslint 17.0.0-beta.8

package/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2017-2023 Narwhal Technologies Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,61 @@
+<p style="text-align: center;"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx.png" width="600" alt="Nx - Smart, Fast and Extensible Build System"></p>
+
+<div style="text-align: center;">
+
+[![CircleCI](https://circleci.com/gh/nrwl/nx.svg?style=svg)](https://circleci.com/gh/nrwl/nx)
+[![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)]()
+[![NPM Version](https://badge.fury.io/js/%40nrwl%2Fworkspace.svg)](https://www.npmjs.com/@nx/workspace)
+[![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)]()
+[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
+[![Join the chat at https://gitter.im/nrwl-nx/community](https://badges.gitter.im/nrwl-nx/community.svg)](https://gitter.im/nrwl-nx/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Join us on the Official Nx Discord Server](https://img.shields.io/discord/1143497901675401286?label=discord)](https://go.nx.dev/community)
+
+</div>
+
+
+<hr>
+
+# Nx: Smart, Fast and Extensible Build System
+
+Nx is a next generation build system with first class monorepo support and powerful integrations.
+
+## Getting Started
+
+### Creating an Nx Workspace
+
+**Using `npx`**
+
+```bash
+npx create-nx-workspace
+```
+
+**Using `npm init`**
+
+```bash
+npm init nx-workspace
+```
+
+**Using `yarn create`**
+
+```bash
+yarn create nx-workspace
+```
+
+### Adding Nx to an Existing Repository
+
+Run:
+
+```bash
+npx nx@latest init
+```
+
+## Documentation & Resources
+
+- [Nx.Dev: Documentation, Guides, Tutorials](https://nx.dev)
+- [Intro to Nx](https://nx.dev/getting-started/intro)
+- [Official Nx YouTube Channel](https://www.youtube.com/@NxDevtools)
+- [Blog Posts About Nx](https://blog.nrwl.io/nx/home)
+
+<p style="text-align: center;"><a href="https://nx.dev/#learning-materials" target="_blank" rel="noreferrer"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-courses-and-videos.svg" 
+width="100%" alt="Nx - Smart, Fast and Extensible Build System"></a></p>
+

package/executors.json

@@ -0,0 +1,10 @@
+{
+  "executors": {
+    "lint": {
+      "implementation": "./src/executors/lint/lint.impl",
+      "schema": "./src/executors/lint/schema.json",
+      "hasher": "./src/executors/lint/hasher",
+      "description": "Run ESLint on a project."
+    }
+  }
+}

package/generators.json

@@ -0,0 +1,22 @@
+{
+  "name": "nx/eslint",
+  "version": "0.1",
+  "generators": {
+    "workspace-rules-project": {
+      "factory": "./src/generators/workspace-rules-project/workspace-rules-project#lintWorkspaceRulesProjectGenerator",
+      "schema": "./src/generators/workspace-rules-project/schema.json",
+      "description": "Create the Workspace Lint Rules Project.",
+      "hidden": true
+    },
+    "workspace-rule": {
+      "factory": "./src/generators/workspace-rule/workspace-rule#lintWorkspaceRuleGenerator",
+      "schema": "./src/generators/workspace-rule/schema.json",
+      "description": "Create a new Workspace ESLint rule."
+    },
+    "convert-to-flat-config": {
+      "factory": "./src/generators/convert-to-flat-config/generator",
+      "schema": "./src/generators/convert-to-flat-config/schema.json",
+      "description": "Convert an Nx workspace's ESLint configs to use Flat Config."
+    }
+  }
+}

package/index.d.ts

@@ -0,0 +1,4 @@
+export { lintProjectGenerator } from './src/generators/lint-project/lint-project';
+export { lintInitGenerator } from './src/generators/init/init';
+export { Linter } from './src/generators/utils/linter';
+export { hasRulesRequiringTypeChecking } from './src/utils/rules-requiring-type-checking';

package/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasRulesRequiringTypeChecking = exports.Linter = exports.lintInitGenerator = exports.lintProjectGenerator = void 0;
+var lint_project_1 = require("./src/generators/lint-project/lint-project");
+Object.defineProperty(exports, "lintProjectGenerator", { enumerable: true, get: function () { return lint_project_1.lintProjectGenerator; } });
+var init_1 = require("./src/generators/init/init");
+Object.defineProperty(exports, "lintInitGenerator", { enumerable: true, get: function () { return init_1.lintInitGenerator; } });
+var linter_1 = require("./src/generators/utils/linter");
+Object.defineProperty(exports, "Linter", { enumerable: true, get: function () { return linter_1.Linter; } });
+// @nx/angular needs it for the Angular CLI workspace migration to Nx to
+// infer whether a config is using type aware rules and set the
+// `hasTypeAwareRules` option of the `@nx/eslint:lint` executor.
+var rules_requiring_type_checking_1 = require("./src/utils/rules-requiring-type-checking");
+Object.defineProperty(exports, "hasRulesRequiringTypeChecking", { enumerable: true, get: function () { return rules_requiring_type_checking_1.hasRulesRequiringTypeChecking; } });

package/migrations.json

@@ -0,0 +1,79 @@
+{
+  "generators": {
+    "add-eslint-inputs": {
+      "cli": "nx",
+      "version": "15.0.0-beta.0",
+      "description": "Stop hashing eslint config files for build targets and dependent tasks",
+      "factory": "./src/migrations/update-15-0-0/add-eslint-inputs"
+    },
+    "add-eslint-ignore": {
+      "cli": "nx",
+      "version": "15.7.1-beta.0",
+      "description": "Add node_modules to root eslint ignore",
+      "factory": "./src/migrations/update-15-7-1/add-eslint-ignore"
+    },
+    "update-16-0-0-add-nx-packages": {
+      "cli": "nx",
+      "version": "16.0.0-beta.1",
+      "description": "Replace @nrwl/linter with @nx/linter",
+      "implementation": "./src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages"
+    },
+    "update-16-8-0-add-ignored-files": {
+      "version": "16.8.0",
+      "description": "update-16-8-0-add-ignored-files",
+      "implementation": "./src/migrations/update-16-8-0-add-ignored-files/update-16-8-0-add-ignored-files"
+    },
+    "update-17-0-0-rename-to-eslint": {
+      "version": "17.0.0-beta.7",
+      "description": "update-17-0-0-rename-to-eslint",
+      "implementation": "./src/migrations/update-17-0-0-rename-to-eslint/update-17-0-0-rename-to-eslint"
+    }
+  },
+  "packageJsonUpdates": {
+    "16.0.0": {
+      "version": "16.0.0-beta.0",
+      "packages": {
+        "@typescript-eslint/parser": {
+          "version": "^5.58.0"
+        },
+        "@typescript-eslint/eslint-plugin": {
+          "version": "^5.58.0"
+        },
+        "@typescript-eslint/utils": {
+          "version": "^5.58.0"
+        }
+      }
+    },
+    "16.5.0": {
+      "version": "16.5.0-beta.2",
+      "packages": {
+        "@typescript-eslint/parser": {
+          "version": "^5.60.1"
+        },
+        "@typescript-eslint/eslint-plugin": {
+          "version": "^5.60.1"
+        },
+        "@typescript-eslint/utils": {
+          "version": "^5.60.1"
+        }
+      }
+    },
+    "16.7.0": {
+      "version": "16.7.0-beta.2",
+      "packages": {
+        "eslint": {
+          "version": "~8.46.0"
+        },
+        "@typescript-eslint/parser": {
+          "version": "^5.60.1"
+        },
+        "@typescript-eslint/eslint-plugin": {
+          "version": "^5.60.1"
+        },
+        "@typescript-eslint/utils": {
+          "version": "^5.60.1"
+        }
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@nx/eslint",
+  "version": "17.0.0-beta.8",
+  "private": false,
+  "description": "The ESLint plugin for Nx contains executors, generators and utilities used for linting JavaScript/TypeScript projects within an Nx workspace.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nrwl/nx.git",
+    "directory": "packages/eslint"
+  },
+  "keywords": [
+    "Monorepo",
+    "Web",
+    "Lint",
+    "ESLint",
+    "CLI"
+  ],
+  "main": "./index.js",
+  "typings": "./index.d.ts",
+  "author": "Victor Savkin",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/nrwl/nx/issues"
+  },
+  "homepage": "https://nx.dev",
+  "ng-update": {
+    "requirements": {},
+    "migrations": "./migrations.json"
+  },
+  "executors": "./executors.json",
+  "generators": "./generators.json",
+  "peerDependencies": {
+    "eslint": "^8.0.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0",
+    "@nx/devkit": "17.0.0-beta.8",
+    "@nx/js": "17.0.0-beta.8",
+    "typescript": "~5.1.3",
+    "@nx/linter": "17.0.0-beta.8"
+  },
+  "peerDependenciesMeta": {
+    "eslint": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "commonjs"
+}

package/src/executors/lint/hasher.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { Hash, ProjectGraph, ProjectsConfigurations, Task, TaskGraph, TaskHasher } from '@nx/devkit';
+export default function run(task: Task, context: {
+    hasher: TaskHasher;
+    projectGraph: ProjectGraph;
+    taskGraph: TaskGraph;
+    projectsConfigurations: ProjectsConfigurations;
+    env: NodeJS.ProcessEnv;
+}): Promise<Hash>;

package/src/executors/lint/hasher.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+async function run(task, context) {
+    const res = await context.hasher.hashTask(task, context.taskGraph, context.env);
+    if (task.overrides['hasTypeAwareRules'] === true) {
+        return res;
+    }
+    const deps = allDeps(task.id, context.taskGraph, context.projectGraph);
+    const tags = (0, devkit_1.hashArray)(deps.map((d) => (context.projectsConfigurations.projects[d].tags || []).join('|')));
+    const command = res.details['command'];
+    let selfSource = '';
+    for (let n of Object.keys(res.details)) {
+        if (n.startsWith(`${task.target.project}:`)) {
+            selfSource = res.details.nodes[n];
+        }
+    }
+    const nodes = {};
+    const hashes = [];
+    for (const d of Object.keys(res.details.nodes)) {
+        if (d.indexOf('$fileset') === -1) {
+            nodes[d] = res.details.nodes[d];
+            hashes.push(res.details.nodes[d]);
+        }
+    }
+    return {
+        value: (0, devkit_1.hashArray)([command, selfSource, ...hashes, tags]),
+        details: {
+            command,
+            nodes: { [task.target.project]: selfSource, tags, ...nodes },
+        },
+    };
+}
+exports.default = run;
+function allDeps(taskId, taskGraph, projectGraph) {
+    if (!taskGraph.tasks) {
+        return [];
+    }
+    const project = taskGraph.tasks[taskId].target.project;
+    return projectGraph.dependencies[project]
+        .filter((d) => !!projectGraph.nodes[d.target])
+        .map((d) => d.target);
+}

package/src/executors/lint/lint.impl.d.ts

@@ -0,0 +1,5 @@
+import { ExecutorContext } from '@nx/devkit';
+import type { Schema } from './schema';
+export default function run(options: Schema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;

package/src/executors/lint/lint.impl.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const eslint_utils_1 = require("./utility/eslint-utils");
+async function run(options, context) {
+    // this is only used for the hasher
+    delete options.hasTypeAwareRules;
+    const systemRoot = context.root;
+    // eslint resolves files relative to the current working directory.
+    // We want these paths to always be resolved relative to the workspace
+    // root to be able to run the lint executor from any subfolder.
+    process.chdir(systemRoot);
+    const projectName = context.projectName || '<???>';
+    const printInfo = options.format && !options.silent;
+    if (printInfo) {
+        console.info(`\nLinting ${JSON.stringify(projectName)}...`);
+    }
+    /**
+     * We want users to have the option of not specifying the config path, and let
+     * eslint automatically resolve the `.eslintrc.json` files in each folder.
+     */
+    let eslintConfigPath = options.eslintConfig
+        ? (0, path_1.resolve)(systemRoot, options.eslintConfig)
+        : undefined;
+    options.cacheLocation = options.cacheLocation
+        ? (0, devkit_1.joinPathFragments)(options.cacheLocation, projectName)
+        : undefined;
+    const { printConfig, ...normalizedOptions } = options;
+    /**
+     * Until ESLint v9 is released and the new so called flat config is the default
+     * we only want to support it if the user has explicitly opted into it by converting
+     * their root ESLint config to use eslint.config.js
+     */
+    const hasFlatConfig = (0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, 'eslint.config.js'));
+    if (!eslintConfigPath && hasFlatConfig) {
+        const projectRoot = context.projectsConfigurations.projects[context.projectName].root;
+        eslintConfigPath = (0, devkit_1.joinPathFragments)(projectRoot, 'eslint.config.js');
+    }
+    const { eslint, ESLint } = await (0, eslint_utils_1.resolveAndInstantiateESLint)(eslintConfigPath, normalizedOptions, hasFlatConfig);
+    const version = ESLint.version?.split('.');
+    if (!version ||
+        version.length < 2 ||
+        Number(version[0]) < 7 ||
+        (Number(version[0]) === 7 && Number(version[1]) < 6)) {
+        throw new Error('ESLint must be version 7.6 or higher.');
+    }
+    if (printConfig) {
+        try {
+            const fileConfig = await eslint.calculateConfigForFile(printConfig);
+            console.log(JSON.stringify(fileConfig, null, ' '));
+            return {
+                success: true,
+            };
+        }
+        catch (err) {
+            console.error(err);
+            return {
+                success: false,
+            };
+        }
+    }
+    let lintResults = [];
+    try {
+        lintResults = await eslint.lintFiles(normalizedOptions.lintFilePatterns);
+    }
+    catch (err) {
+        if (err.message.includes('You must therefore provide a value for the "parserOptions.project" property for @typescript-eslint/parser')) {
+            let eslintConfigPathForError = `for ${projectName}`;
+            if (context.projectsConfigurations?.projects?.[projectName]?.root) {
+                const { root } = context.projectsConfigurations.projects[projectName];
+                eslintConfigPathForError = `\`${root}/.eslintrc.json\``;
+            }
+            console.error(`
+Error: You have attempted to use a lint rule which requires the full TypeScript type-checker to be available, but you do not have \`parserOptions.project\` configured to point at your project tsconfig.json files in the relevant TypeScript file "overrides" block of your project ESLint config ${eslintConfigPath || eslintConfigPathForError}
+
+Please see https://nx.dev/guides/eslint for full guidance on how to resolve this issue.
+`);
+            return {
+                success: false,
+            };
+        }
+        // If some unexpected error, rethrow
+        throw err;
+    }
+    if (lintResults.length === 0) {
+        const ignoredPatterns = (await Promise.all(normalizedOptions.lintFilePatterns.map(async (pattern) => (await eslint.isPathIgnored(pattern)) ? pattern : null)))
+            .filter((pattern) => !!pattern)
+            .map((pattern) => `- '${pattern}'`);
+        if (ignoredPatterns.length) {
+            const ignoreSection = hasFlatConfig
+                ? `'ignores' configuration`
+                : `'.eslintignore' file`;
+            throw new Error(`All files matching the following patterns are ignored:\n${ignoredPatterns.join('\n')}\n\nPlease check your ${ignoreSection}.`);
+        }
+        throw new Error('Invalid lint configuration. Nothing to lint. Please check your lint target pattern(s).');
+    }
+    // output fixes to disk, if applicable based on the options
+    await ESLint.outputFixes(lintResults);
+    // if quiet, only show errors
+    if (normalizedOptions.quiet) {
+        console.debug('Quiet mode enabled - filtering out warnings\n');
+        lintResults = ESLint.getErrorResults(lintResults);
+    }
+    const formatter = await eslint.loadFormatter(normalizedOptions.format);
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    for (const result of lintResults) {
+        if (result.errorCount || result.warningCount) {
+            totalErrors += result.errorCount;
+            totalWarnings += result.warningCount;
+        }
+    }
+    const formattedResults = await formatter.format(lintResults);
+    if (normalizedOptions.outputFile) {
+        const pathToOutputFile = (0, devkit_1.joinPathFragments)(context.root, normalizedOptions.outputFile);
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(pathToOutputFile), { recursive: true });
+        (0, fs_1.writeFileSync)(pathToOutputFile, formattedResults);
+    }
+    else {
+        console.info(formattedResults);
+    }
+    if (totalWarnings > 0 && printInfo) {
+        console.warn('Lint warnings found in the listed files.\n');
+    }
+    if (totalErrors > 0 && printInfo) {
+        console.error('Lint errors found in the listed files.\n');
+    }
+    if (totalWarnings === 0 && totalErrors === 0 && printInfo) {
+        console.info('All files pass linting.\n');
+    }
+    return {
+        success: normalizedOptions.force ||
+            (totalErrors === 0 &&
+                (normalizedOptions.maxWarnings === -1 ||
+                    totalWarnings <= normalizedOptions.maxWarnings)),
+    };
+}
+exports.default = run;

package/src/executors/lint/schema.d.ts

@@ -0,0 +1,39 @@
+import type { JsonObject } from '@angular-devkit/core';
+import type { Linter } from 'eslint';
+
+export interface Schema extends JsonObject {
+  eslintConfig: string | null;
+  lintFilePatterns: string[];
+  format: Formatter;
+  force: boolean;
+  silent: boolean;
+  fix: boolean;
+  cache: boolean;
+  noEslintrc: boolean;
+  outputFile: string | null;
+  cacheLocation: string | null;
+  maxWarnings: number;
+  quiet: boolean;
+  ignorePath: string | null;
+  hasTypeAwareRules: boolean;
+  cacheStrategy: 'content' | 'metadata' | null;
+  rulesdir: string[];
+  resolvePluginsRelativeTo: string | null;
+  reportUnusedDisableDirectives: Linter.StringSeverity | null;
+  printConfig?: string | null;
+}
+
+type Formatter =
+  | 'stylish'
+  | 'compact'
+  | 'codeframe'
+  | 'unix'
+  | 'visualstudio'
+  | 'table'
+  | 'checkstyle'
+  | 'html'
+  | 'jslint-xml'
+  | 'json'
+  | 'json-with-metadata'
+  | 'junit'
+  | 'tap';

package/src/executors/lint/schema.json

@@ -0,0 +1,144 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "$schema": "http://json-schema.org/schema",
+  "title": "ESLint Lint Target",
+  "description": "ESLint Lint Target.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "eslintConfig": {
+      "type": "string",
+      "description": "The name of the ESLint configuration file.",
+      "x-completion-type": "file",
+      "x-completion-glob": ".eslintrc?(.json)",
+      "x-priority": "important"
+    },
+    "lintFilePatterns": {
+      "type": "array",
+      "description": "One or more files/dirs/globs to pass directly to ESLint's `lintFiles()` method.",
+      "default": [],
+      "items": {
+        "type": "string"
+      }
+    },
+    "format": {
+      "type": "string",
+      "description": "ESLint Output formatter (https://eslint.org/docs/user-guide/formatters).",
+      "default": "stylish",
+      "anyOf": [
+        {
+          "enum": [
+            "stylish",
+            "compact",
+            "codeframe",
+            "unix",
+            "visualstudio",
+            "table",
+            "checkstyle",
+            "html",
+            "jslint-xml",
+            "json",
+            "json-with-metadata",
+            "junit",
+            "tap"
+          ]
+        },
+        {
+          "minLength": 1
+        }
+      ],
+      "x-priority": "important"
+    },
+    "force": {
+      "type": "boolean",
+      "description": "Succeeds even if there was linting errors.",
+      "default": false
+    },
+    "silent": {
+      "type": "boolean",
+      "description": "Hide output text.",
+      "default": false
+    },
+    "fix": {
+      "type": "boolean",
+      "description": "Fixes linting errors (may overwrite linted files).",
+      "default": false,
+      "x-priority": "important"
+    },
+    "cache": {
+      "type": "boolean",
+      "description": "Only check changed files.",
+      "default": false
+    },
+    "cacheLocation": {
+      "type": "string",
+      "description": "Path to the cache file or directory.",
+      "x-completion-type": "directory",
+      "x-completion-glob": "tsconfig.*.json"
+    },
+    "outputFile": {
+      "type": "string",
+      "description": "File to write report to.",
+      "x-completion-type": "file"
+    },
+    "maxWarnings": {
+      "type": "number",
+      "description": "Number of warnings to trigger nonzero exit code - default: `-1`.",
+      "default": -1
+    },
+    "quiet": {
+      "type": "boolean",
+      "description": "Report errors only - default: `false`.",
+      "default": false,
+      "x-priority": "important"
+    },
+    "ignorePath": {
+      "type": "string",
+      "description": "The path of the `.eslintignore` file. Not supported for Flat Config.",
+      "x-completion-type": "file",
+      "x-completion-glob": ".eslintignore"
+    },
+    "noEslintrc": {
+      "type": "boolean",
+      "description": "The equivalent of the `--no-eslintrc` flag on the ESLint CLI, it is `false` by default.",
+      "default": false
+    },
+    "hasTypeAwareRules": {
+      "type": "boolean",
+      "description": "When set to `true`, the linter will invalidate its cache when any of its dependencies changes."
+    },
+    "cacheStrategy": {
+      "type": "string",
+      "description": "Strategy to use for detecting changed files in the cache.",
+      "default": "metadata",
+      "enum": ["metadata", "content"]
+    },
+    "rulesdir": {
+      "type": "array",
+      "description": "The equivalent of the `--rulesdir` flag on the ESLint CLI.",
+      "default": [],
+      "items": {
+        "type": "string",
+        "x-completion-type": "directory"
+      }
+    },
+    "resolvePluginsRelativeTo": {
+      "type": "string",
+      "description": "The equivalent of the `--resolve-plugins-relative-to` flag on the ESLint CLI. Not supported for Flat Config.",
+      "x-completion-type": "directory"
+    },
+    "reportUnusedDisableDirectives": {
+      "type": "string",
+      "enum": ["off", "warn", "error"],
+      "description": "The equivalent of the `--report-unused-disable-directives` flag on the ESLint CLI."
+    },
+    "printConfig": {
+      "type": "string",
+      "description": "The equivalent of the `--print-config` flag on the ESLint CLI.",
+      "x-completion-type": "file"
+    }
+  },
+  "required": ["lintFilePatterns"],
+  "examplesFile": "../../../docs/eslint-examples.md"
+}

package/src/executors/lint/utility/eslint-utils.d.ts

@@ -0,0 +1,6 @@
+import type { ESLint } from 'eslint';
+import type { Schema } from '../schema';
+export declare function resolveAndInstantiateESLint(eslintConfigPath: string | undefined, options: Schema, useFlatConfig?: boolean): Promise<{
+    ESLint: typeof import("eslint").ESLint;
+    eslint: ESLint;
+}>;