@nx/eslint 0.0.0-pr-22179-271588f → 0.0.0-pr-26515-856ef7f

package/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2017-2023 Narwhal Technologies Inc.
+Copyright (c) 2017-2024 Narwhal Technologies Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

package/generators.json

@@ -23,6 +23,11 @@
       "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."
+    },
+    "convert-to-inferred": {
+      "factory": "./src/generators/convert-to-inferred/convert-to-inferred",
+      "schema": "./src/generators/convert-to-inferred/schema.json",
+      "description": "Convert existing ESLint project(s) using `@nx/eslint:lint` executor to use `@nx/eslint/plugin`."
     }
   }
 }

package/migrations.json

@@ -1,17 +1,5 @@
 {
   "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",
@@ -133,6 +121,23 @@
           "version": "^6.13.2"
         }
       }
+    },
+    "18.2.0": {
+      "version": "18.2.0-beta.0",
+      "packages": {
+        "@typescript-eslint/parser": {
+          "version": "^7.3.0"
+        },
+        "@typescript-eslint/eslint-plugin": {
+          "version": "^7.3.0"
+        },
+        "@typescript-eslint/utils": {
+          "version": "^7.3.0"
+        },
+        "eslint": {
+          "version": "~8.57.0"
+        }
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/eslint",
-  "version": "0.0.0-pr-22179-271588f",
+  "version": "0.0.0-pr-26515-856ef7f",
   "private": false,
   "description": "The ESLint plugin for Nx contains executors, generators and utilities used for linting JavaScript/TypeScript projects within an Nx workspace.",
   "repository": {
@@ -13,9 +13,10 @@
     "Web",
     "Lint",
     "ESLint",
-    "CLI"
+    "CLI",
+    "Testing"
   ],
-  "main": "./index.js",
+  "main": "./index",
   "typings": "./index.d.ts",
   "author": "Victor Savkin",
   "license": "MIT",
@@ -30,18 +31,19 @@
   "generators": "./generators.json",
   "executors": "./executors.json",
   "peerDependencies": {
-    "js-yaml": "4.1.0"
+    "@zkochan/js-yaml": "0.0.7",
+    "eslint": "^8.0.0 || ^9.0.0"
   },
   "dependencies": {
-    "@nx/devkit": "0.0.0-pr-22179-271588f",
-    "@nx/js": "0.0.0-pr-22179-271588f",
-    "eslint": "^8.0.0",
+    "@nx/devkit": "0.0.0-pr-26515-856ef7f",
+    "@nx/js": "0.0.0-pr-26515-856ef7f",
+    "semver": "^7.5.3",
     "tslib": "^2.3.0",
-    "typescript": "~5.3.2",
-    "@nx/linter": "0.0.0-pr-22179-271588f"
+    "typescript": "~5.4.2",
+    "@nx/linter": "0.0.0-pr-26515-856ef7f"
   },
   "peerDependenciesMeta": {
-    "js-yaml": {
+    "@zkochan/js-yaml": {
       "optional": true
     }
   },

package/plugin.d.ts

@@ -1 +1 @@
-export { createNodes, EslintPluginOptions } from './src/plugins/plugin';
+export { createNodes, createNodesV2, EslintPluginOptions, } from './src/plugins/plugin';

package/plugin.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodes = void 0;
+exports.createNodesV2 = exports.createNodes = void 0;
 var plugin_1 = require("./src/plugins/plugin");
 Object.defineProperty(exports, "createNodes", { enumerable: true, get: function () { return plugin_1.createNodes; } });
+Object.defineProperty(exports, "createNodesV2", { enumerable: true, get: function () { return plugin_1.createNodesV2; } });

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

@@ -1,4 +1,4 @@
-import { ExecutorContext } from '@nx/devkit';
+import { type 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

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const devkit_1 = require("@nx/devkit");
 const fs_1 = require("fs");
+const utils_1 = require("nx/src/tasks-runner/utils");
 const path_1 = require("path");
+const config_file_1 = require("../../utils/config-file");
 const eslint_utils_1 = require("./utility/eslint-utils");
-const utils_1 = require("nx/src/tasks-runner/utils");
 async function run(options, context) {
     // this is only used for the hasher
     delete options.hasTypeAwareRules;
@@ -23,19 +24,14 @@ async function run(options, context) {
         ? (0, devkit_1.joinPathFragments)(options.cacheLocation, projectName)
         : undefined;
     const { printConfig, errorOnUnmatchedPattern, ...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'));
+    // locate the flat config file if it exists starting from the project root
+    const flatConfigFilePath = (0, config_file_1.findFlatConfigFile)(projectRoot, context.root);
+    const hasFlatConfig = flatConfigFilePath !== null;
     // while standard eslint uses by default closest config to the file, if otherwise not specified,
-    // the flat config would always use the root config, so we need to explicitly set it to the local one
+    // the flat config would be resolved starting from the cwd, which we changed to the workspace root
+    // so we explicitly set the config path to the flat config file path we previously found
     if (hasFlatConfig && !normalizedOptions.eslintConfig) {
-        const eslintConfigPath = (0, devkit_1.joinPathFragments)(projectRoot, 'eslint.config.js');
-        if ((0, fs_1.existsSync)(eslintConfigPath)) {
-            normalizedOptions.eslintConfig = eslintConfigPath;
-        }
+        normalizedOptions.eslintConfig = path_1.posix.relative(systemRoot, flatConfigFilePath);
     }
     /**
      * We want users to have the option of not specifying the config path, and let
@@ -81,15 +77,24 @@ async function run(options, context) {
     catch (err) {
         if (err.message.includes('You must therefore provide a value for the "parserOptions.project" property for @typescript-eslint/parser')) {
             const ruleName = err.message.match(/rule '([^']+)':/)?.[1];
-            let eslintConfigPathForError = `for ${projectName}`;
-            if (context.projectsConfigurations?.projects?.[projectName]?.root) {
-                const { root } = context.projectsConfigurations.projects[projectName];
-                eslintConfigPathForError = `\`${root}/.eslintrc.json\``;
+            const reportedFile = err.message.match(/Occurred while linting (.+)$/)?.[1];
+            let eslintConfigPathForError = `for the project "${projectName}"`;
+            if (eslintConfigPath) {
+                eslintConfigPathForError = `"${path_1.posix.relative(context.root, eslintConfigPath)}"`;
+            }
+            else {
+                const configPathForfile = hasFlatConfig
+                    ? (0, config_file_1.findFlatConfigFile)(projectRoot, context.root)
+                    : (0, config_file_1.findOldConfigFile)(reportedFile ?? projectRoot, context.root);
+                if (configPathForfile) {
+                    eslintConfigPathForError = `"${path_1.posix.relative(context.root, configPathForfile)}"`;
+                }
             }
             console.error(`
-Error: You have attempted to use ${ruleName ? `the lint rule ${ruleName}` : '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}
+Error: You have attempted to use ${ruleName ? `the lint rule "${ruleName}"` : '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 ESLint config ${eslintConfigPathForError}
+${reportedFile ? `Occurred while linting ${reportedFile}` : ''}
 
-Please see https://nx.dev/guides/eslint for full guidance on how to resolve this issue.
+Please see https://nx.dev/recipes/tips-n-tricks/eslint for full guidance on how to resolve this issue.
 `);
             return {
                 success: false,

package/src/executors/lint/utility/eslint-utils.js

@@ -1,26 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveAndInstantiateESLint = void 0;
-async function resolveESLintClass(useFlatConfig = false) {
-    try {
-        if (!useFlatConfig) {
-            return (await Promise.resolve().then(() => require('eslint'))).ESLint;
-        }
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { FlatESLint } = require('eslint/use-at-your-own-risk');
-        return FlatESLint;
-    }
-    catch {
-        throw new Error('Unable to find ESLint. Ensure ESLint is installed.');
-    }
-}
+const config_file_1 = require("../../../utils/config-file");
+const resolve_eslint_class_1 = require("../../../utils/resolve-eslint-class");
 async function resolveAndInstantiateESLint(eslintConfigPath, options, useFlatConfig = false) {
-    if (useFlatConfig &&
-        eslintConfigPath &&
-        !eslintConfigPath?.endsWith('eslint.config.js')) {
+    if (useFlatConfig && eslintConfigPath && !(0, config_file_1.isFlatConfig)(eslintConfigPath)) {
         throw new Error('When using the new Flat Config with ESLint, all configs must be named eslint.config.js and .eslintrc files may not be used. See https://eslint.org/docs/latest/use/configure/configuration-files-new');
     }
-    const ESLint = await resolveESLintClass(useFlatConfig);
+    const ESLint = await (0, resolve_eslint_class_1.resolveESLintClass)(useFlatConfig);
     const eslintOptions = {
         overrideConfigFile: eslintConfigPath,
         fix: !!options.fix,

package/src/generators/convert-to-flat-config/generator.d.ts

@@ -1,4 +1,4 @@
-import { Tree } from '@nx/devkit';
+import { GeneratorCallback, Tree } from '@nx/devkit';
 import { ConvertToFlatConfigGeneratorSchema } from './schema';
-export declare function convertToFlatConfigGenerator(tree: Tree, options: ConvertToFlatConfigGeneratorSchema): Promise<void>;
+export declare function convertToFlatConfigGenerator(tree: Tree, options: ConvertToFlatConfigGeneratorSchema): Promise<void | GeneratorCallback>;
 export default convertToFlatConfigGenerator;

package/src/generators/convert-to-flat-config/generator.js

@@ -6,7 +6,7 @@ const eslint_file_1 = require("../utils/eslint-file");
 const path_1 = require("path");
 const versions_1 = require("../../utils/versions");
 const json_converter_1 = require("./converters/json-converter");
-const js_yaml_1 = require("js-yaml");
+let shouldInstallDeps = false;
 async function convertToFlatConfigGenerator(tree, options) {
     const eslintFile = (0, eslint_file_1.findEslintFile)(tree);
     if (!eslintFile) {
@@ -33,6 +33,9 @@ async function convertToFlatConfigGenerator(tree, options) {
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }
+    if (shouldInstallDeps) {
+        return () => (0, devkit_1.installPackagesTask)(tree);
+    }
 }
 exports.convertToFlatConfigGenerator = convertToFlatConfigGenerator;
 exports.default = convertToFlatConfigGenerator;
@@ -112,7 +115,8 @@ function convertConfigToFlatConfig(tree, root, source, target, ignorePath) {
     }
     if (source.endsWith('.yaml') || source.endsWith('.yml')) {
         const originalContent = tree.read(`${root}/${source}`, 'utf-8');
-        const config = (0, js_yaml_1.load)(originalContent, {
+        const { load } = require('@zkochan/js-yaml');
+        const config = load(originalContent, {
             json: true,
             filename: source,
         });
@@ -127,11 +131,13 @@ function processConvertedConfig(tree, root, source, target, { content, addESLint
     tree.write((0, path_1.join)(root, target), content);
     // add missing packages
     if (addESLintRC) {
+        shouldInstallDeps = true;
         (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
             '@eslint/eslintrc': versions_1.eslintrcVersion,
         });
     }
     if (addESLintJS) {
+        shouldInstallDeps = true;
         (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
             '@eslint/js': versions_1.eslintVersion,
         });

package/src/generators/convert-to-inferred/convert-to-inferred.d.ts

@@ -0,0 +1,7 @@
+import { type Tree } from '@nx/devkit';
+interface Schema {
+    project?: string;
+    skipFormat?: boolean;
+}
+export declare function convertToInferred(tree: Tree, options: Schema): Promise<void>;
+export default convertToInferred;

package/src/generators/convert-to-inferred/convert-to-inferred.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToInferred = void 0;
+const devkit_1 = require("@nx/devkit");
+const plugin_1 = require("../../plugins/plugin");
+const executor_to_plugin_migrator_1 = require("@nx/devkit/src/generators/plugin-migrations/executor-to-plugin-migrator");
+const target_options_map_1 = require("./lib/target-options-map");
+const utils_1 = require("nx/src/tasks-runner/utils");
+async function convertToInferred(tree, options) {
+    const projectGraph = await (0, devkit_1.createProjectGraphAsync)();
+    const migratedProjectsModern = await (0, executor_to_plugin_migrator_1.migrateExecutorToPlugin)(tree, projectGraph, '@nx/eslint:lint', '@nx/eslint/plugin', (targetName) => ({ targetName }), postTargetTransformer, plugin_1.createNodesV2, options.project);
+    const migratedProjectsLegacy = await (0, executor_to_plugin_migrator_1.migrateExecutorToPlugin)(tree, projectGraph, '@nrwl/linter:eslint', '@nx/eslint/plugin', (targetName) => ({ targetName }), postTargetTransformer, plugin_1.createNodesV2, options.project);
+    const migratedProjects = migratedProjectsModern.size + migratedProjectsLegacy.size;
+    if (migratedProjects === 0) {
+        throw new Error('Could not find any targets to migrate.');
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.convertToInferred = convertToInferred;
+function postTargetTransformer(target, tree, projectDetails) {
+    if (target.inputs) {
+        const inputs = target.inputs.filter((input) => typeof input === 'string' &&
+            ![
+                'default',
+                '{workspaceRoot}/.eslintrc.json',
+                '{workspaceRoot}/.eslintignore',
+                '{workspaceRoot}/eslint.config.js',
+            ].includes(input));
+        if (inputs.length === 0) {
+            delete target.inputs;
+        }
+    }
+    if (target.options) {
+        if ('eslintConfig' in target.options) {
+            delete target.options.eslintConfig;
+        }
+        if ('force' in target.options) {
+            delete target.options.force;
+        }
+        if ('silent' in target.options) {
+            delete target.options.silent;
+        }
+        if ('hasTypeAwareRules' in target.options) {
+            delete target.options.hasTypeAwareRules;
+        }
+        if ('errorOnUnmatchedPattern' in target.options) {
+            if (!target.options.errorOnUnmatchedPattern) {
+                target.options['no-error-on-unmatched-pattern'] = true;
+            }
+            delete target.options.errorOnUnmatchedPattern;
+        }
+        if ('outputFile' in target.options) {
+            target.outputs ??= [];
+            target.outputs.push(target.options.outputFile);
+        }
+        for (const key in target_options_map_1.targetOptionsToCliMap) {
+            if (target.options[key]) {
+                target.options[target_options_map_1.targetOptionsToCliMap[key]] = target.options[key];
+                delete target.options[key];
+            }
+        }
+        if ('lintFilePatterns' in target.options) {
+            const normalizedLintFilePatterns = target.options.lintFilePatterns.map((pattern) => {
+                return (0, utils_1.interpolate)(pattern, {
+                    workspaceRoot: '',
+                    projectRoot: projectDetails.root,
+                    projectName: projectDetails.projectName,
+                });
+            });
+            target.options.args = normalizedLintFilePatterns.map((pattern) => pattern.startsWith(projectDetails.root)
+                ? pattern.replace(new RegExp(`^${projectDetails.root}/`), './')
+                : pattern);
+            delete target.options.lintFilePatterns;
+        }
+    }
+    return target;
+}
+exports.default = convertToInferred;

package/src/generators/convert-to-inferred/lib/target-options-map.d.ts

@@ -0,0 +1,16 @@
+export declare const targetOptionsToCliMap: {
+    fix: string;
+    format: string;
+    cache: string;
+    cacheLocation: string;
+    cacheStrategy: string;
+    noEslintrc: string;
+    outputFile: string;
+    maxWarnings: string;
+    quiet: string;
+    ignorePath: string;
+    rulesdir: string;
+    resolvePluginsRelativeTo: string;
+    reportUnusedDisableDirectives: string;
+    printConfig: string;
+};

package/src/generators/convert-to-inferred/lib/target-options-map.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.targetOptionsToCliMap = void 0;
+exports.targetOptionsToCliMap = {
+    fix: 'fix',
+    format: 'format',
+    cache: 'cache',
+    cacheLocation: 'cache-location',
+    cacheStrategy: 'cache-strategy',
+    noEslintrc: 'no-eslintrc',
+    outputFile: 'output-file',
+    maxWarnings: 'max-warnings',
+    quiet: 'quiet',
+    ignorePath: 'ignore-path',
+    rulesdir: 'rulesdir',
+    resolvePluginsRelativeTo: 'resolve-plugins-relative-to',
+    reportUnusedDisableDirectives: 'report-unused-disable-directives',
+    printConfig: 'print-config',
+};

package/src/generators/convert-to-inferred/schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxEslintConvertToInferred",
+  "description": "Convert existing Eslint project(s) using `@nx/eslint:lint` executor to use `@nx/eslint/plugin`. Defaults to migrating all projects. Pass '--project' to migrate only one target.",
+  "title": "Convert Eslint project from executor to plugin",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The project to convert from using the `@nx/eslint:lint` executor to use `@nx/eslint/plugin`.",
+      "x-priority": "important"
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Whether to format files at the end of the migration.",
+      "default": false
+    }
+  }
+}

package/src/generators/init/init-migration.js

@@ -104,6 +104,10 @@ function migrateEslintFile(projectEslintPath, tree) {
                 }
                 // add extends
                 json.extends = json.extends || [];
+                // ensure extends is an array
+                if (typeof json.extends === 'string') {
+                    json.extends = [json.extends];
+                }
                 const pathToRootConfig = `${(0, devkit_1.offsetFromRoot)((0, path_1.dirname)(projectEslintPath))}${baseFile}`;
                 if (json.extends.indexOf(pathToRootConfig) === -1) {
                     json.extends.push(pathToRootConfig);

package/src/generators/init/init.d.ts

@@ -1,4 +1,4 @@
-import type { GeneratorCallback, Tree } from '@nx/devkit';
+import { GeneratorCallback, Tree } from '@nx/devkit';
 export interface LinterInitOptions {
     skipPackageJson?: boolean;
     keepExistingVersions?: boolean;

package/src/generators/init/init.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lintInitGenerator = exports.initEsLint = void 0;
 const devkit_1 = require("@nx/devkit");
-const update_package_scripts_1 = require("@nx/devkit/src/utils/update-package-scripts");
+const add_plugin_1 = require("@nx/devkit/src/utils/add-plugin");
 const versions_1 = require("../../utils/versions");
 const eslint_file_1 = require("../utils/eslint-file");
 const plugin_1 = require("../../plugins/plugin");
@@ -31,24 +31,6 @@ function addTargetDefaults(tree) {
     ];
     (0, devkit_1.updateNxJson)(tree, nxJson);
 }
-function addPlugin(tree) {
-    const nxJson = (0, devkit_1.readNxJson)(tree);
-    nxJson.plugins ??= [];
-    for (const plugin of nxJson.plugins) {
-        if (typeof plugin === 'string'
-            ? plugin === '@nx/eslint/plugin'
-            : plugin.plugin === '@nx/eslint/plugin') {
-            return;
-        }
-    }
-    nxJson.plugins.push({
-        plugin: '@nx/eslint/plugin',
-        options: {
-            targetName: 'lint',
-        },
-    });
-    (0, devkit_1.updateNxJson)(tree, nxJson);
-}
 async function initEsLint(tree, options) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
     const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
@@ -56,11 +38,19 @@ async function initEsLint(tree, options) {
     options.addPlugin ??= addPluginDefault;
     const hasPlugin = (0, plugin_2.hasEslintPlugin)(tree);
     const rootEslintFile = (0, eslint_file_1.findEslintFile)(tree);
+    const graph = await (0, devkit_1.createProjectGraphAsync)();
+    const lintTargetNames = [
+        'lint',
+        'eslint:lint',
+        'eslint-lint',
+        '_lint',
+        '_eslint:lint',
+        '_eslint-lint',
+    ];
     if (rootEslintFile && options.addPlugin && !hasPlugin) {
-        addPlugin(tree);
-        if (options.updatePackageScripts) {
-            await (0, update_package_scripts_1.updatePackageScripts)(tree, plugin_1.createNodes);
-        }
+        await (0, add_plugin_1.addPlugin)(tree, graph, '@nx/eslint/plugin', plugin_1.createNodesV2, {
+            targetName: lintTargetNames,
+        }, options.updatePackageScripts);
         return () => { };
     }
     if (rootEslintFile) {
@@ -68,7 +58,9 @@ async function initEsLint(tree, options) {
     }
     updateProductionFileset(tree);
     if (options.addPlugin) {
-        addPlugin(tree);
+        await (0, add_plugin_1.addPlugin)(tree, graph, '@nx/eslint/plugin', plugin_1.createNodesV2, {
+            targetName: lintTargetNames,
+        }, options.updatePackageScripts);
     }
     else {
         addTargetDefaults(tree);
@@ -81,9 +73,6 @@ async function initEsLint(tree, options) {
             eslint: versions_1.eslintVersion,
         }, undefined, options.keepExistingVersions));
     }
-    if (options.updatePackageScripts) {
-        await (0, update_package_scripts_1.updatePackageScripts)(tree, plugin_1.createNodes);
-    }
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
 exports.initEsLint = initEsLint;

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

@@ -1,4 +1,4 @@
-import type { GeneratorCallback, Tree } from '@nx/devkit';
+import { GeneratorCallback, Tree } from '@nx/devkit';
 import { Linter as LinterEnum } from '../utils/linter';
 interface LintProjectOptions {
     project: string;
@@ -16,6 +16,7 @@ interface LintProjectOptions {
      * @internal
      */
     addExplicitTargets?: boolean;
+    addPackageJsonDependencyChecks?: boolean;
 }
 export declare function lintProjectGenerator(tree: Tree, options: LintProjectOptions): Promise<GeneratorCallback>;
 export declare function lintProjectGeneratorInternal(tree: Tree, options: LintProjectOptions): Promise<GeneratorCallback>;

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

@@ -73,7 +73,8 @@ async function lintProjectGeneratorInternal(tree, options) {
     if (!options.rootProject) {
         const projects = {};
         (0, project_configuration_1.getProjects)(tree).forEach((v, k) => (projects[k] = v));
-        if (isMigrationToMonorepoNeeded(projects, tree)) {
+        const graph = await (0, devkit_1.createProjectGraphAsync)();
+        if (isMigrationToMonorepoNeeded(tree, graph)) {
             // we only migrate project configurations that have been created
             const filteredProjects = [];
             Object.entries(projects).forEach(([name, project]) => {
@@ -88,7 +89,7 @@ async function lintProjectGeneratorInternal(tree, options) {
     // additionally, the companion e2e app would have `rootProject: true`
     // so we need to check for the root path as well
     if (!options.rootProject || projectConfig.root !== '.') {
-        createEsLintConfiguration(tree, projectConfig, options.setParserOptionsProject, options.rootProject);
+        createEsLintConfiguration(tree, options, projectConfig, options.setParserOptionsProject, options.rootProject);
     }
     // Buildable libs need source analysis enabled for linting `package.json`.
     if (isBuildableLibraryProject(projectConfig) &&
@@ -107,7 +108,7 @@ async function lintProjectGeneratorInternal(tree, options) {
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
 exports.lintProjectGeneratorInternal = lintProjectGeneratorInternal;
-function createEsLintConfiguration(tree, projectConfig, setParserOptionsProject, rootProject) {
+function createEsLintConfiguration(tree, options, projectConfig, setParserOptionsProject, rootProject) {
     // we are only extending root for non-standalone projects or their complementary e2e apps
     const extendedRootConfig = rootProject ? undefined : (0, eslint_file_1.findEslintFile)(tree);
     const pathToRootConfig = extendedRootConfig
@@ -150,7 +151,8 @@ function createEsLintConfiguration(tree, projectConfig, setParserOptionsProject,
             rules: {},
         },
     ];
-    if (isBuildableLibraryProject(projectConfig)) {
+    if (options.addPackageJsonDependencyChecks ||
+        isBuildableLibraryProject(projectConfig)) {
         overrides.push({
             files: ['*.json'],
             parser: 'jsonc-eslint-parser',
@@ -198,30 +200,24 @@ function isBuildableLibraryProject(projectConfig) {
  * Detect based on the state of lint target configuration of the root project
  * if we should migrate eslint configs to monorepo style
  */
-function isMigrationToMonorepoNeeded(projects, tree) {
+function isMigrationToMonorepoNeeded(tree, graph) {
     // the base config is already created, migration has been done
     if (tree.exists(config_file_1.baseEsLintConfigFile) ||
         tree.exists(config_file_1.baseEsLintFlatConfigFile)) {
         return false;
     }
-    const configs = Object.values(projects);
-    if (configs.length === 1) {
-        return false;
-    }
+    const nodes = Object.values(graph.nodes);
     // get root project
-    const rootProject = configs.find((p) => p.root === '.');
-    if (!rootProject || !rootProject.targets) {
+    const rootProject = nodes.find((p) => p.data.root === '.');
+    if (!rootProject || !rootProject.data.targets) {
         return false;
     }
-    // check if we're inferring lint target from `@nx/eslint/plugin`
-    if ((0, plugin_1.hasEslintPlugin)(tree)) {
-        for (const f of config_file_1.ESLINT_CONFIG_FILENAMES) {
-            if (tree.exists(f)) {
-                return true;
-            }
+    for (const targetConfig of Object.values(rootProject.data.targets ?? {})) {
+        if (['@nx/eslint:lint', '@nrwl/linter:eslint', '@nx/linter:eslint'].includes(targetConfig.executor) ||
+            (targetConfig.executor === 'nx:run-commands' &&
+                targetConfig.options?.command.startsWith('eslint '))) {
+            return true;
         }
     }
-    // find if root project has lint target
-    const lintTarget = (0, init_migration_1.findLintTarget)(rootProject);
-    return !!lintTarget;
+    return false;
 }

package/src/generators/utils/eslint-file.js

@@ -189,7 +189,7 @@ function replaceOverridesInLintConfig(tree, root, overrides) {
         content = (0, ast_utils_1.removeOverridesFromLintConfig)(content);
         overrides.forEach((override) => {
             const flatOverride = (0, ast_utils_1.generateFlatOverride)(override);
-            (0, ast_utils_1.addBlockToFlatConfigExport)(content, flatOverride);
+            content = (0, ast_utils_1.addBlockToFlatConfigExport)(content, flatOverride);
         });
         tree.write(fileName, content);
     }
@@ -209,7 +209,9 @@ function addExtendsToLintConfig(tree, root, plugin) {
         const pluginExtends = (0, ast_utils_1.generatePluginExtendsElement)(plugins);
         let content = tree.read(fileName, 'utf8');
         content = (0, ast_utils_1.addCompatToFlatConfig)(content);
-        tree.write(fileName, (0, ast_utils_1.addBlockToFlatConfigExport)(content, pluginExtends));
+        tree.write(fileName, (0, ast_utils_1.addBlockToFlatConfigExport)(content, pluginExtends, {
+            insertAtTheEnd: false,
+        }));
     }
     else {
         const fileName = (0, devkit_1.joinPathFragments)(root, '.eslintrc.json');

package/src/generators/utils/flat-config/ast-utils.js

@@ -4,6 +4,11 @@ exports.generateAst = exports.mapFilePaths = exports.generateFlatOverride = expo
 const devkit_1 = require("@nx/devkit");
 const ts = require("typescript");
 const path_utils_1 = require("./path-utils");
+/**
+ * Supports direct identifiers, and those nested within an object (of arbitrary depth)
+ * E.g. `...foo` and `...foo.bar.baz.qux` etc
+ */
+const SPREAD_ELEMENTS_REGEXP = /\s*\.\.\.[a-zA-Z0-9_]+(\.[a-zA-Z0-9_]+)*,?\n?/g;
 /**
  * Remove all overrides from the config file
  */
@@ -58,11 +63,13 @@ function hasOverride(content, lookup) {
             let objSource;
             if (ts.isObjectLiteralExpression(node)) {
                 objSource = node.getFullText();
+                // strip any spread elements
+                objSource = objSource.replace(SPREAD_ELEMENTS_REGEXP, '');
             }
             else {
                 const fullNodeText = node['expression'].arguments[0].body.expression.getFullText();
                 // strip any spread elements
-                objSource = fullNodeText.replace(/\s*\.\.\.[a-zA-Z0-9_]+,?\n?/, '');
+                objSource = fullNodeText.replace(SPREAD_ELEMENTS_REGEXP, '');
             }
             const data = (0, devkit_1.parseJson)(objSource
                 // ensure property names have double quotes so that JSON.parse works
@@ -76,7 +83,6 @@ function hasOverride(content, lookup) {
     return false;
 }
 exports.hasOverride = hasOverride;
-const STRIP_SPREAD_ELEMENTS = /\s*\.\.\.[a-zA-Z0-9_]+,?\n?/g;
 function parseTextToJson(text) {
     return (0, devkit_1.parseJson)(text
         // ensure property names have double quotes so that JSON.parse works
@@ -105,7 +111,7 @@ function replaceOverride(content, root, lookup, update) {
             else {
                 const fullNodeText = node['expression'].arguments[0].body.expression.getFullText();
                 // strip any spread elements
-                objSource = fullNodeText.replace(STRIP_SPREAD_ELEMENTS, '');
+                objSource = fullNodeText.replace(SPREAD_ELEMENTS_REGEXP, '');
                 start =
                     node['expression'].arguments[0].body.expression.properties.pos +
                         (fullNodeText.length - objSource.length);
@@ -283,7 +289,7 @@ function removePlugin(content, pluginName, pluginImport) {
                         const pluginsArray = pluginsElem.initializer;
                         const plugins = parseTextToJson(pluginsElem.initializer
                             .getText()
-                            .replace(STRIP_SPREAD_ELEMENTS, ''));
+                            .replace(SPREAD_ELEMENTS_REGEXP, ''));
                         if (plugins.length > 1) {
                             changes.push({
                                 type: devkit_1.ChangeType.Delete,
@@ -419,7 +425,7 @@ function addCompatToFlatConfig(content) {
     if (result.includes('const compat = new FlatCompat')) {
         return result;
     }
-    result = addImportToFlatConfig(result, 'FlatCompat', '@eslint/eslintrc');
+    result = addImportToFlatConfig(result, ['FlatCompat'], '@eslint/eslintrc');
     const index = result.indexOf('module.exports');
     return (0, devkit_1.applyChangesToString)(result, [
         {
@@ -502,15 +508,33 @@ function generateFlatOverride(override) {
         !override.extends &&
         !override.plugins &&
         !override.parser) {
+        if (override.parserOptions) {
+            const { parserOptions, ...rest } = override;
+            return generateAst({ ...rest, languageOptions: { parserOptions } });
+        }
         return generateAst(override);
     }
-    const { files, excludedFiles, rules, ...rest } = override;
+    const { files, excludedFiles, rules, parserOptions, ...rest } = override;
     const objectLiteralElements = [
         ts.factory.createSpreadAssignment(ts.factory.createIdentifier('config')),
     ];
     addTSObjectProperty(objectLiteralElements, 'files', files);
     addTSObjectProperty(objectLiteralElements, 'excludedFiles', excludedFiles);
-    addTSObjectProperty(objectLiteralElements, 'rules', rules);
+    // Apply rules (and spread ...config.rules into it as the first assignment)
+    addTSObjectProperty(objectLiteralElements, 'rules', rules || {});
+    const rulesObjectAST = objectLiteralElements.pop();
+    const rulesObjectInitializer = rulesObjectAST.initializer;
+    const spreadAssignment = ts.factory.createSpreadAssignment(ts.factory.createIdentifier('config.rules'));
+    const updatedRulesProperties = [
+        spreadAssignment,
+        ...rulesObjectInitializer.properties,
+    ];
+    objectLiteralElements.push(ts.factory.createPropertyAssignment('rules', ts.factory.createObjectLiteralExpression(updatedRulesProperties, true)));
+    if (parserOptions) {
+        addTSObjectProperty(objectLiteralElements, 'languageOptions', {
+            parserOptions,
+        });
+    }
     return ts.factory.createSpreadElement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('compat'), ts.factory.createIdentifier('config')), undefined, [generateAst(rest)]), ts.factory.createIdentifier('map')), undefined, [
         ts.factory.createArrowFunction(undefined, undefined, [
             ts.factory.createParameterDeclaration(undefined, undefined, 'config'),

package/src/plugins/plugin.d.ts

@@ -1,5 +1,7 @@
-import { CreateNodes } from '@nx/devkit';
+import { CreateNodes, CreateNodesV2 } from '@nx/devkit';
 export interface EslintPluginOptions {
     targetName?: string;
+    extensions?: string[];
 }
+export declare const createNodesV2: CreateNodesV2<EslintPluginOptions>;
 export declare const createNodes: CreateNodes<EslintPluginOptions>;

package/src/plugins/plugin.js

@@ -1,85 +1,169 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodes = void 0;
-const path_1 = require("path");
-const fs_1 = require("fs");
+exports.createNodes = exports.createNodesV2 = void 0;
+const devkit_1 = require("@nx/devkit");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const globs_1 = require("nx/src/utils/globs");
+const workspace_context_1 = require("nx/src/utils/workspace-context");
 const config_file_1 = require("../utils/config-file");
+const resolve_eslint_class_1 = require("../utils/resolve-eslint-class");
+const semver_1 = require("semver");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const file_hasher_1 = require("nx/src/hasher/file-hasher");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const DEFAULT_EXTENSIONS = ['ts', 'tsx', 'js', 'jsx', 'html', 'vue'];
+const ESLINT_CONFIG_GLOB = (0, globs_1.combineGlobPatterns)([
+    ...config_file_1.ESLINT_CONFIG_FILENAMES.map((f) => `**/${f}`),
+]);
+function readTargetsCache(cachePath) {
+    return (0, node_fs_1.existsSync)(cachePath) ? (0, devkit_1.readJsonFile)(cachePath) : {};
+}
+function writeTargetsToCache(cachePath, results) {
+    (0, devkit_1.writeJsonFile)(cachePath, results);
+}
+const internalCreateNodes = async (configFilePath, options, context, projectsCache) => {
+    options = normalizeOptions(options);
+    const configDir = (0, node_path_1.dirname)(configFilePath);
+    // Ensure that configFiles are set, e2e-run fails due to them being undefined in CI (does not occur locally)
+    // TODO(JamesHenry): Further troubleshoot this in CI
+    context.configFiles = context.configFiles ?? [];
+    // Create a Set of all the directories containing eslint configs, and a
+    // list of globs to exclude from child projects
+    const eslintRoots = new Set();
+    const nestedEslintRootPatterns = [];
+    for (const configFile of context.configFiles) {
+        const eslintRootDir = (0, node_path_1.dirname)(configFile);
+        eslintRoots.add(eslintRootDir);
+        if (eslintRootDir !== configDir && isSubDir(configDir, eslintRootDir)) {
+            nestedEslintRootPatterns.push(`${eslintRootDir}/**/*`);
+        }
+    }
+    const projectFiles = await (0, workspace_context_1.globWithWorkspaceContext)(context.workspaceRoot, ['project.json', 'package.json', '**/project.json', '**/package.json'].map((f) => (0, node_path_1.join)(configDir, f)), nestedEslintRootPatterns.length ? nestedEslintRootPatterns : undefined);
+    // dedupe and sort project roots by depth for more efficient traversal
+    const dedupedProjectRoots = Array.from(new Set(projectFiles.map((f) => (0, node_path_1.dirname)(f)))).sort((a, b) => (a !== b && isSubDir(a, b) ? -1 : 1));
+    const excludePatterns = dedupedProjectRoots.map((root) => `${root}/**/*`);
+    const ESLint = await (0, resolve_eslint_class_1.resolveESLintClass)((0, config_file_1.isFlatConfig)(configFilePath));
+    const eslintVersion = ESLint.version;
+    const childProjectRoots = new Set();
+    const projects = {};
+    await Promise.all(dedupedProjectRoots.map(async (childProjectRoot, index) => {
+        // anything after is either a nested project or a sibling project, can be excluded
+        const nestedProjectRootPatterns = excludePatterns.slice(index + 1);
+        // Ignore project roots where the project does not contain any lintable files
+        const lintableFiles = await (0, workspace_context_1.globWithWorkspaceContext)(context.workspaceRoot, [(0, node_path_1.join)(childProjectRoot, `**/*.{${options.extensions.join(',')}}`)], 
+        // exclude nested eslint roots and nested project roots
+        [...nestedEslintRootPatterns, ...nestedProjectRootPatterns]);
+        const parentConfigs = context.configFiles.filter((eslintConfig) => isSubDir(childProjectRoot, (0, node_path_1.dirname)(eslintConfig)));
+        const hash = await (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(childProjectRoot, options, context, [...parentConfigs, (0, node_path_1.join)(childProjectRoot, '.eslintignore')]);
+        if (projectsCache[hash]) {
+            // We can reuse the projects in the cache.
+            Object.assign(projects, projectsCache[hash]);
+            return;
+        }
+        const eslint = new ESLint({
+            cwd: (0, node_path_1.join)(context.workspaceRoot, childProjectRoot),
+        });
+        for (const file of lintableFiles) {
+            if (!(await eslint.isPathIgnored((0, node_path_1.join)(context.workspaceRoot, file)))) {
+                childProjectRoots.add(childProjectRoot);
+                break;
+            }
+        }
+        const uniqueChildProjectRoots = Array.from(childProjectRoots);
+        const projectsForRoot = getProjectsUsingESLintConfig(configFilePath, uniqueChildProjectRoots, eslintVersion, options, context);
+        if (Object.keys(projectsForRoot).length > 0) {
+            Object.assign(projects, projectsForRoot);
+            // Store those projects into the cache;
+            projectsCache[hash] = projectsForRoot;
+        }
+    }));
+    return {
+        projects,
+    };
+};
+exports.createNodesV2 = [
+    ESLINT_CONFIG_GLOB,
+    async (configFiles, options, context) => {
+        const optionsHash = (0, file_hasher_1.hashObject)(options);
+        const cachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `eslint-${optionsHash}.hash`);
+        const targetsCache = readTargetsCache(cachePath);
+        try {
+            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => internalCreateNodes(configFile, options, context, targetsCache), configFiles, options, context);
+        }
+        finally {
+            writeTargetsToCache(cachePath, targetsCache);
+        }
+    },
+];
 exports.createNodes = [
-    (0, globs_1.combineGlobPatterns)(['**/project.json', '**/package.json']),
+    ESLINT_CONFIG_GLOB,
     (configFilePath, options, context) => {
-        const projectRoot = (0, path_1.dirname)(configFilePath);
-        options = normalizeOptions(options);
-        const eslintConfigs = getEslintConfigsForProject(projectRoot, context.workspaceRoot);
-        if (!eslintConfigs.length) {
-            return {};
-        }
-        return {
-            projects: {
-                [projectRoot]: {
-                    targets: buildEslintTargets(eslintConfigs, projectRoot, options),
-                },
-            },
-        };
+        devkit_1.logger.warn('`createNodes` is deprecated. Update your plugin to utilize createNodesV2 instead. In Nx 20, this will change to the createNodesV2 API.');
+        return internalCreateNodes(configFilePath, options, context, {});
     },
 ];
-function getEslintConfigsForProject(projectRoot, workspaceRoot) {
-    const detectedConfigs = new Set();
-    const baseConfig = (0, config_file_1.findBaseEslintFile)(workspaceRoot);
-    if (baseConfig) {
-        detectedConfigs.add(baseConfig);
-    }
-    let siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(workspaceRoot, projectRoot));
-    if (projectRoot === '.') {
-        // If there's no src folder, it's not a standalone project
-        if (!siblingFiles.includes('src')) {
-            return [];
+function getProjectsUsingESLintConfig(configFilePath, childProjectRoots, eslintVersion, options, context) {
+    const projects = {};
+    const rootEslintConfig = [
+        config_file_1.baseEsLintConfigFile,
+        config_file_1.baseEsLintFlatConfigFile,
+        ...config_file_1.ESLINT_CONFIG_FILENAMES,
+    ].find((f) => (0, node_fs_1.existsSync)((0, node_path_1.join)(context.workspaceRoot, f)));
+    // Add a lint target for each child project without an eslint config, with the root level config as an input
+    for (const projectRoot of childProjectRoots) {
+        let standaloneSrcPath;
+        if (projectRoot === '.' &&
+            (0, node_fs_1.existsSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot, 'package.json'))) {
+            if ((0, node_fs_1.existsSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot, 'src'))) {
+                standaloneSrcPath = 'src';
+            }
+            else if ((0, node_fs_1.existsSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot, 'lib'))) {
+                standaloneSrcPath = 'lib';
+            }
         }
-        // If it's standalone but doesn't have eslint config, it's not a lintable
-        const config = siblingFiles.find((f) => config_file_1.ESLINT_CONFIG_FILENAMES.includes(f));
-        if (!config) {
-            return [];
+        if (projectRoot === '.' && !standaloneSrcPath) {
+            continue;
         }
-        detectedConfigs.add(config);
-        return Array.from(detectedConfigs);
-    }
-    while (projectRoot !== '.') {
-        // if it has an eslint config it's lintable
-        const config = siblingFiles.find((f) => config_file_1.ESLINT_CONFIG_FILENAMES.includes(f));
-        if (config) {
-            detectedConfigs.add(`${projectRoot}/${config}`);
-            return Array.from(detectedConfigs);
+        const eslintConfigs = [configFilePath];
+        if (rootEslintConfig && !eslintConfigs.includes(rootEslintConfig)) {
+            eslintConfigs.unshift(rootEslintConfig);
         }
-        projectRoot = (0, path_1.dirname)(projectRoot);
-        siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(workspaceRoot, projectRoot));
-    }
-    // check whether the root has an eslint config
-    const config = (0, fs_1.readdirSync)(workspaceRoot).find((f) => config_file_1.ESLINT_CONFIG_FILENAMES.includes(f));
-    if (config) {
-        detectedConfigs.add(config);
-        return Array.from(detectedConfigs);
+        projects[projectRoot] = {
+            targets: buildEslintTargets(eslintConfigs, eslintVersion, projectRoot, context.workspaceRoot, options, standaloneSrcPath),
+        };
     }
-    return [];
+    return projects;
 }
-function buildEslintTargets(eslintConfigs, projectRoot, options) {
+function buildEslintTargets(eslintConfigs, eslintVersion, projectRoot, workspaceRoot, options, standaloneSrcPath) {
     const isRootProject = projectRoot === '.';
     const targets = {};
     const targetConfig = {
-        command: `eslint ${isRootProject ? './src' : '.'}`,
+        command: `eslint ${isRootProject && standaloneSrcPath ? `./${standaloneSrcPath}` : '.'}`,
         cache: true,
         options: {
             cwd: projectRoot,
         },
         inputs: [
             'default',
-            ...eslintConfigs.map((config) => `{workspaceRoot}/${config}`),
+            // Certain lint rules can be impacted by changes to dependencies
+            '^default',
+            ...eslintConfigs.map((config) => `{workspaceRoot}/${config}`.replace(`{workspaceRoot}/${projectRoot}`, isRootProject ? '{projectRoot}/' : '{projectRoot}')),
+            ...((0, node_fs_1.existsSync)((0, node_path_1.join)(workspaceRoot, projectRoot, '.eslintignore'))
+                ? ['{projectRoot}/.eslintignore']
+                : []),
             '{workspaceRoot}/tools/eslint-rules/**/*',
             { externalDependencies: ['eslint'] },
         ],
+        outputs: ['{options.outputFile}'],
     };
-    if (eslintConfigs.some((config) => (0, config_file_1.isFlatConfig)(config))) {
+    // Always set the environment variable to ensure that the ESLint CLI can run on eslint v8 and v9
+    const useFlatConfig = eslintConfigs.some((config) => (0, config_file_1.isFlatConfig)(config));
+    // Flat config is default for 9.0.0+
+    const defaultSetting = (0, semver_1.gte)(eslintVersion, '9.0.0');
+    if (useFlatConfig !== defaultSetting) {
         targetConfig.options.env = {
-            ESLINT_USE_FLAT_CONFIG: 'true',
+            ESLINT_USE_FLAT_CONFIG: useFlatConfig ? 'true' : 'false',
         };
     }
     targets[options.targetName] = targetConfig;
@@ -88,5 +172,28 @@ function buildEslintTargets(eslintConfigs, projectRoot, options) {
 function normalizeOptions(options) {
     options ??= {};
     options.targetName ??= 'lint';
+    // Normalize user input for extensions (strip leading . characters)
+    if (Array.isArray(options.extensions)) {
+        options.extensions = options.extensions.map((f) => f.replace(/^\.+/, ''));
+    }
+    else {
+        options.extensions = DEFAULT_EXTENSIONS;
+    }
     return options;
 }
+/**
+ * Determines if `child` is a subdirectory of `parent`. This is a simplified
+ * version that takes into account that paths are always relative to the
+ * workspace root.
+ */
+function isSubDir(parent, child) {
+    if (parent === '.') {
+        return true;
+    }
+    parent = (0, node_path_1.normalize)(parent);
+    child = (0, node_path_1.normalize)(child);
+    if (!parent.endsWith(node_path_1.sep)) {
+        parent += node_path_1.sep;
+    }
+    return child.startsWith(parent);
+}

package/src/utils/config-file.d.ts

@@ -1,5 +1,8 @@
+export declare const ESLINT_FLAT_CONFIG_FILENAMES: string[];
+export declare const ESLINT_OLD_CONFIG_FILENAMES: string[];
 export declare const ESLINT_CONFIG_FILENAMES: string[];
 export declare const baseEsLintConfigFile = ".eslintrc.base.json";
 export declare const baseEsLintFlatConfigFile = "eslint.base.config.js";
-export declare function findBaseEslintFile(workspaceRoot?: string): string | null;
 export declare function isFlatConfig(configFilePath: string): boolean;
+export declare function findFlatConfigFile(directory: string, workspaceRoot: string): string | null;
+export declare function findOldConfigFile(filePathOrDirectory: string, workspaceRoot: string): string | null;

package/src/utils/config-file.js

@@ -1,35 +1,69 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFlatConfig = exports.findBaseEslintFile = exports.baseEsLintFlatConfigFile = exports.baseEsLintConfigFile = exports.ESLINT_CONFIG_FILENAMES = void 0;
-const devkit_1 = require("@nx/devkit");
+exports.findOldConfigFile = exports.findFlatConfigFile = exports.isFlatConfig = exports.baseEsLintFlatConfigFile = exports.baseEsLintConfigFile = exports.ESLINT_CONFIG_FILENAMES = exports.ESLINT_OLD_CONFIG_FILENAMES = exports.ESLINT_FLAT_CONFIG_FILENAMES = void 0;
 const fs_1 = require("fs");
-exports.ESLINT_CONFIG_FILENAMES = [
+const path_1 = require("path");
+// TODO(leo): add support for eslint.config.mjs and eslint.config.cjs
+exports.ESLINT_FLAT_CONFIG_FILENAMES = ['eslint.config.js'];
+exports.ESLINT_OLD_CONFIG_FILENAMES = [
     '.eslintrc',
     '.eslintrc.js',
     '.eslintrc.cjs',
     '.eslintrc.yaml',
     '.eslintrc.yml',
     '.eslintrc.json',
-    'eslint.config.js',
+];
+exports.ESLINT_CONFIG_FILENAMES = [
+    ...exports.ESLINT_OLD_CONFIG_FILENAMES,
+    ...exports.ESLINT_FLAT_CONFIG_FILENAMES,
 ];
 exports.baseEsLintConfigFile = '.eslintrc.base.json';
 exports.baseEsLintFlatConfigFile = 'eslint.base.config.js';
-function findBaseEslintFile(workspaceRoot = '') {
-    if ((0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(workspaceRoot, exports.baseEsLintConfigFile))) {
-        return exports.baseEsLintConfigFile;
+function isFlatConfig(configFilePath) {
+    const configFileName = (0, path_1.basename)(configFilePath);
+    return exports.ESLINT_FLAT_CONFIG_FILENAMES.includes(configFileName);
+}
+exports.isFlatConfig = isFlatConfig;
+// https://eslint.org/docs/latest/use/configure/configuration-files#configuration-file-resolution
+function findFlatConfigFile(directory, workspaceRoot) {
+    let currentDir = (0, path_1.resolve)(workspaceRoot, directory);
+    while (true) {
+        const configFilePath = getConfigFileInDirectory(currentDir, exports.ESLINT_FLAT_CONFIG_FILENAMES);
+        if (configFilePath) {
+            return configFilePath;
+        }
+        if (currentDir === workspaceRoot) {
+            break;
+        }
+        currentDir = (0, path_1.dirname)(currentDir);
     }
-    if ((0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(workspaceRoot, exports.baseEsLintFlatConfigFile))) {
-        return exports.baseEsLintFlatConfigFile;
+    return null;
+}
+exports.findFlatConfigFile = findFlatConfigFile;
+function findOldConfigFile(filePathOrDirectory, workspaceRoot) {
+    let currentDir = (0, path_1.resolve)(workspaceRoot, filePathOrDirectory);
+    if (!(0, fs_1.statSync)(currentDir).isDirectory()) {
+        currentDir = (0, path_1.dirname)(currentDir);
     }
-    for (const file of exports.ESLINT_CONFIG_FILENAMES) {
-        if ((0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(workspaceRoot, file))) {
-            return file;
+    while (true) {
+        const configFilePath = getConfigFileInDirectory(currentDir, exports.ESLINT_OLD_CONFIG_FILENAMES);
+        if (configFilePath) {
+            return configFilePath;
         }
+        if (currentDir === workspaceRoot) {
+            break;
+        }
+        currentDir = (0, path_1.dirname)(currentDir);
     }
     return null;
 }
-exports.findBaseEslintFile = findBaseEslintFile;
-function isFlatConfig(configFilePath) {
-    return configFilePath.endsWith('.config.js');
+exports.findOldConfigFile = findOldConfigFile;
+function getConfigFileInDirectory(directory, candidateFileNames) {
+    for (const filename of candidateFileNames) {
+        const filePath = (0, path_1.join)(directory, filename);
+        if ((0, fs_1.existsSync)(filePath)) {
+            return filePath;
+        }
+    }
+    return null;
 }
-exports.isFlatConfig = isFlatConfig;

package/src/utils/resolve-eslint-class.d.ts

@@ -0,0 +1,2 @@
+import type { ESLint } from 'eslint';
+export declare function resolveESLintClass(useFlatConfig?: boolean): Promise<typeof ESLint>;

package/src/utils/resolve-eslint-class.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveESLintClass = void 0;
+async function resolveESLintClass(useFlatConfig = false) {
+    try {
+        // In eslint 8.57.0 (the final v8 version), a dedicated API was added for resolving the correct ESLint class.
+        const eslint = await Promise.resolve().then(() => require('eslint'));
+        if (typeof eslint.loadESLint === 'function') {
+            return await eslint.loadESLint({ useFlatConfig });
+        }
+        // If that API is not available (an older version of v8), we need to use the old way of resolving the ESLint class.
+        if (!useFlatConfig) {
+            return eslint.ESLint;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { FlatESLint } = require('eslint/use-at-your-own-risk');
+        return FlatESLint;
+    }
+    catch {
+        throw new Error('Unable to find ESLint. Ensure ESLint is installed.');
+    }
+}
+exports.resolveESLintClass = resolveESLintClass;

package/src/utils/versions.d.ts

@@ -1,5 +1,5 @@
 export declare const nxVersion: any;
-export declare const eslintVersion = "~8.48.0";
+export declare const eslintVersion = "~8.57.0";
 export declare const eslintrcVersion = "^2.1.1";
 export declare const eslintConfigPrettierVersion = "^9.0.0";
-export declare const typescriptESLintVersion = "^6.13.2";
+export declare const typescriptESLintVersion = "^7.3.0";

package/src/utils/versions.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.typescriptESLintVersion = exports.eslintConfigPrettierVersion = exports.eslintrcVersion = exports.eslintVersion = exports.nxVersion = void 0;
 exports.nxVersion = require('../../package.json').version;
-exports.eslintVersion = '~8.48.0';
+exports.eslintVersion = '~8.57.0';
 exports.eslintrcVersion = '^2.1.1';
 exports.eslintConfigPrettierVersion = '^9.0.0';
-exports.typescriptESLintVersion = '^6.13.2';
+exports.typescriptESLintVersion = '^7.3.0';

package/src/migrations/update-15-0-0/add-eslint-inputs.d.ts

@@ -1,2 +0,0 @@
-import { Tree } from '@nx/devkit';
-export default function addEslintInputs(tree: Tree): Promise<void>;

package/src/migrations/update-15-0-0/add-eslint-inputs.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const devkit_1 = require("@nx/devkit");
-const eslint_targets_1 = require("../../generators/utils/eslint-targets");
-const config_file_1 = require("../../utils/config-file");
-async function addEslintInputs(tree) {
-    const nxJson = (0, devkit_1.readNxJson)(tree);
-    const globalEslintFile = config_file_1.ESLINT_CONFIG_FILENAMES.find((file) => tree.exists(file));
-    if (globalEslintFile && nxJson.namedInputs?.production) {
-        const productionFileset = new Set(nxJson.namedInputs.production);
-        productionFileset.add(`!{projectRoot}/${globalEslintFile}`);
-        nxJson.namedInputs.production = Array.from(productionFileset);
-    }
-    for (const targetName of (0, eslint_targets_1.getEslintTargets)(tree)) {
-        nxJson.targetDefaults ??= {};
-        const lintTargetDefaults = (nxJson.targetDefaults[targetName] ??= {});
-        lintTargetDefaults.inputs ??= [
-            'default',
-            ...(globalEslintFile
-                ? [(0, devkit_1.joinPathFragments)('{workspaceRoot}', globalEslintFile)]
-                : []),
-        ];
-    }
-    (0, devkit_1.updateNxJson)(tree, nxJson);
-    await (0, devkit_1.formatFiles)(tree);
-}
-exports.default = addEslintInputs;

package/src/migrations/update-15-7-1/add-eslint-ignore.d.ts

@@ -1,2 +0,0 @@
-import { Tree } from '@nx/devkit';
-export default function addEslintIgnore(tree: Tree): Promise<void>;

package/src/migrations/update-15-7-1/add-eslint-ignore.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const devkit_1 = require("@nx/devkit");
-const eslint_targets_1 = require("../../generators/utils/eslint-targets");
-const config_file_1 = require("../../utils/config-file");
-async function addEslintIgnore(tree) {
-    const nxJson = (0, devkit_1.readJson)(tree, 'nx.json');
-    const globalEslintFile = config_file_1.ESLINT_CONFIG_FILENAMES.find((file) => tree.exists(file));
-    if (globalEslintFile) {
-        if (tree.exists('.eslintignore')) {
-            const content = tree.read('.eslintignore', 'utf-8');
-            if (!content.includes('node_modules')) {
-                tree.write('.eslintignore', `node_modules\n${content}`);
-            }
-        }
-        else {
-            tree.write('.eslintignore', 'node_modules\n');
-        }
-        for (const targetName of (0, eslint_targets_1.getEslintTargets)(tree)) {
-            nxJson.targetDefaults ??= {};
-            const lintTargetDefaults = (nxJson.targetDefaults[targetName] ??= {});
-            const lintIgnorePath = (0, devkit_1.joinPathFragments)('{workspaceRoot}', globalEslintFile);
-            if (lintTargetDefaults.inputs) {
-                if (!lintTargetDefaults.inputs.includes(lintIgnorePath)) {
-                    lintTargetDefaults.inputs.push(lintIgnorePath);
-                }
-            }
-            else {
-                lintTargetDefaults.inputs = ['default', lintIgnorePath];
-            }
-        }
-        (0, devkit_1.updateNxJson)(tree, nxJson);
-        await (0, devkit_1.formatFiles)(tree);
-    }
-}
-exports.default = addEslintIgnore;