@nx/eslint 0.0.0-pr-27786-e5e2109 → 0.0.0-pr-27404-f7ba497

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/eslint",
-  "version": "0.0.0-pr-27786-e5e2109",
+  "version": "0.0.0-pr-27404-f7ba497",
   "private": false,
   "description": "The ESLint plugin for Nx contains executors, generators and utilities used for linting JavaScript/TypeScript projects within an Nx workspace.",
   "repository": {
@@ -35,12 +35,12 @@
     "eslint": "^8.0.0 || ^9.0.0"
   },
   "dependencies": {
-    "@nx/devkit": "0.0.0-pr-27786-e5e2109",
-    "@nx/js": "0.0.0-pr-27786-e5e2109",
+    "@nx/devkit": "0.0.0-pr-27404-f7ba497",
+    "@nx/js": "0.0.0-pr-27404-f7ba497",
     "semver": "^7.5.3",
     "tslib": "^2.3.0",
     "typescript": "~5.4.2",
-    "@nx/linter": "0.0.0-pr-27786-e5e2109"
+    "@nx/linter": "0.0.0-pr-27404-f7ba497"
   },
   "peerDependenciesMeta": {
     "@zkochan/js-yaml": {

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

@@ -9,7 +9,9 @@ async function resolveAndInstantiateESLint(eslintConfigPath, options, useFlatCon
         // todo: add support for eslint.config.mjs,
         'When using the new Flat Config with ESLint, all configs must be named eslint.config.js or eslint.config.cjs and .eslintrc files may not be used. See https://eslint.org/docs/latest/use/configure/configuration-files');
     }
-    const ESLint = await (0, resolve_eslint_class_1.resolveESLintClass)(useFlatConfig);
+    const ESLint = await (0, resolve_eslint_class_1.resolveESLintClass)({
+        useFlatConfigOverrideVal: useFlatConfig,
+    });
     const eslintOptions = {
         overrideConfigFile: eslintConfigPath,
         fix: !!options.fix,

package/src/generators/convert-to-flat-config/converters/json-converter.js

@@ -71,6 +71,18 @@ function convertEslintJsonToFlatConfig(tree, root, config, ignorePaths) {
                 isFlatCompatNeeded = true;
             }
             exportElements.push((0, ast_utils_1.generateFlatOverride)(override));
+            // eslint-plugin-import cannot be used with ESLint v9 yet
+            // TODO(jack): Once v9 support is released, remove this block.
+            // See: https://github.com/import-js/eslint-plugin-import/pull/2996
+            if (override.extends === 'plugin:@nx/react') {
+                exportElements.push((0, ast_utils_1.generateFlatOverride)({
+                    rules: {
+                        'import/first': 'off',
+                        'import/no-amd': 'off',
+                        'import/no-webpack-loader-syntax': 'off',
+                    },
+                }));
+            }
         });
     }
     if (config.ignorePatterns) {
@@ -96,9 +108,13 @@ function convertEslintJsonToFlatConfig(tree, root, config, ignorePaths) {
         }
     }
     // create the node list and print it to new file
-    const nodeList = (0, ast_utils_1.createNodeList)(importsMap, exportElements, isFlatCompatNeeded);
+    const nodeList = (0, ast_utils_1.createNodeList)(importsMap, exportElements);
+    let content = (0, ast_utils_1.stringifyNodeList)(nodeList);
+    if (isFlatCompatNeeded) {
+        content = (0, ast_utils_1.addFlatCompatToFlatConfig)(content);
+    }
     return {
-        content: (0, ast_utils_1.stringifyNodeList)(nodeList),
+        content,
         addESLintRC: isFlatCompatNeeded,
         addESLintJS: isESLintJSNeeded,
     };

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

@@ -6,7 +6,6 @@ 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");
-let shouldInstallDeps = false;
 async function convertToFlatConfigGenerator(tree, options) {
     const eslintFile = (0, eslint_file_1.findEslintFile)(tree);
     if (!eslintFile) {
@@ -33,9 +32,7 @@ async function convertToFlatConfigGenerator(tree, options) {
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }
-    if (shouldInstallDeps) {
-        return () => (0, devkit_1.installPackagesTask)(tree);
-    }
+    return () => (0, devkit_1.installPackagesTask)(tree);
 }
 exports.default = convertToFlatConfigGenerator;
 function convertRootToFlatConfig(tree, eslintFile) {
@@ -128,17 +125,18 @@ function processConvertedConfig(tree, root, source, target, { content, addESLint
     tree.delete((0, path_1.join)(root, source));
     // save new
     tree.write((0, path_1.join)(root, target), content);
+    // These dependencies are required for flat configs that are generated by subsequent app/lib generators.
+    const devDependencies = {
+        eslint: versions_1.eslint9__eslintVersion,
+        'eslint-config-prettier': versions_1.eslintConfigPrettierVersion,
+        'typescript-eslint': versions_1.eslint9__typescriptESLintVersion,
+    };
     // add missing packages
     if (addESLintRC) {
-        shouldInstallDeps = true;
-        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
-            '@eslint/eslintrc': versions_1.eslintrcVersion,
-        });
+        devDependencies['@eslint/eslintrc'] = versions_1.eslintrcVersion;
     }
     if (addESLintJS) {
-        shouldInstallDeps = true;
-        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
-            '@eslint/js': versions_1.eslintVersion,
-        });
+        devDependencies['@eslint/js'] = versions_1.eslintVersion;
     }
+    (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies);
 }

package/src/generators/init/global-eslint-config.d.ts

@@ -26,4 +26,4 @@ export declare const javaScriptOverride: {
     rules: {};
 };
 export declare const getGlobalEsLintConfiguration: (unitTestRunner?: string, rootProject?: boolean) => Linter.Config;
-export declare const getGlobalFlatEslintConfiguration: (unitTestRunner?: string, rootProject?: boolean) => string;
+export declare const getGlobalFlatEslintConfiguration: (rootProject?: boolean) => string;

package/src/generators/init/global-eslint-config.js

@@ -78,24 +78,19 @@ const getGlobalEsLintConfiguration = (unitTestRunner, rootProject) => {
     return config;
 };
 exports.getGlobalEsLintConfiguration = getGlobalEsLintConfiguration;
-const getGlobalFlatEslintConfiguration = (unitTestRunner, rootProject) => {
-    const nodeList = (0, ast_utils_1.createNodeList)(new Map(), [], true);
+const getGlobalFlatEslintConfiguration = (rootProject) => {
+    const nodeList = (0, ast_utils_1.createNodeList)(new Map(), []);
     let content = (0, ast_utils_1.stringifyNodeList)(nodeList);
-    content = (0, ast_utils_1.addImportToFlatConfig)(content, 'nxPlugin', '@nx/eslint-plugin');
-    content = (0, ast_utils_1.addPluginsToExportsBlock)(content, [
-        { name: '@nx', varName: 'nxPlugin', imp: '@nx/eslint-plugin' },
-    ]);
+    content = (0, ast_utils_1.addImportToFlatConfig)(content, 'nx', '@nx/eslint-plugin');
+    content = (0, ast_utils_1.addBlockToFlatConfigExport)(content, (0, ast_utils_1.generateFlatPredefinedConfig)('flat/base'), { insertAtTheEnd: false });
+    content = (0, ast_utils_1.addBlockToFlatConfigExport)(content, (0, ast_utils_1.generateFlatPredefinedConfig)('flat/typescript'));
+    content = (0, ast_utils_1.addBlockToFlatConfigExport)(content, (0, ast_utils_1.generateFlatPredefinedConfig)('flat/javascript'));
     if (!rootProject) {
         content = (0, ast_utils_1.addBlockToFlatConfigExport)(content, (0, ast_utils_1.generateFlatOverride)(moduleBoundariesOverride));
     }
-    content = (0, ast_utils_1.addBlockToFlatConfigExport)(content, (0, ast_utils_1.generateFlatOverride)(exports.typeScriptOverride));
-    content = (0, ast_utils_1.addBlockToFlatConfigExport)(content, (0, ast_utils_1.generateFlatOverride)(exports.javaScriptOverride));
-    if (unitTestRunner === 'jest') {
-        content = (0, ast_utils_1.addBlockToFlatConfigExport)(content, (0, ast_utils_1.generateFlatOverride)(jestOverride));
-    }
-    // add ignore for .nx folder
-    content = (0, ast_utils_1.addBlockToFlatConfigExport)(content, (0, ast_utils_1.generateAst)({
-        ignores: ['.nx'],
+    content = (0, ast_utils_1.addBlockToFlatConfigExport)(content, (0, ast_utils_1.generateFlatOverride)({
+        files: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'],
+        rules: {},
     }));
     return content;
 };

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

@@ -29,7 +29,7 @@ function migrateConfigToMonorepoStyle(projects, tree, unitTestRunner, keepExisti
             }, undefined, keepExistingVersions);
             tree.write(tree.exists('eslint.config.js')
                 ? 'eslint.base.config.js'
-                : 'eslint.config.js', (0, global_eslint_config_1.getGlobalFlatEslintConfiguration)(unitTestRunner));
+                : 'eslint.config.js', (0, global_eslint_config_1.getGlobalFlatEslintConfiguration)());
         }
         else {
             const eslintFile = (0, eslint_file_1.findEslintFile)(tree, '.');

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

@@ -114,55 +114,63 @@ function createEsLintConfiguration(tree, options, projectConfig, setParserOption
     const pathToRootConfig = extendedRootConfig
         ? `${(0, devkit_1.offsetFromRoot)(projectConfig.root)}${extendedRootConfig}`
         : undefined;
-    const addDependencyChecks = isBuildableLibraryProject(projectConfig);
-    const overrides = [
-        {
-            files: ['*.ts', '*.tsx', '*.js', '*.jsx'],
-            /**
-             * NOTE: We no longer set parserOptions.project by default when creating new projects.
-             *
-             * We have observed that users rarely add rules requiring type-checking to their Nx workspaces, and therefore
-             * do not actually need the capabilites which parserOptions.project provides. When specifying parserOptions.project,
-             * typescript-eslint needs to create full TypeScript Programs for you. When omitting it, it can perform a simple
-             * parse (and AST tranformation) of the source files it encounters during a lint run, which is much faster and much
-             * less memory intensive.
-             *
-             * In the rare case that users attempt to add rules requiring type-checking to their setup later on (and haven't set
-             * parserOptions.project), the executor will attempt to look for the particular error typescript-eslint gives you
-             * and provide feedback to the user.
-             */
-            parserOptions: !setParserOptionsProject
-                ? undefined
-                : {
-                    project: [`${projectConfig.root}/tsconfig.*?.json`],
-                },
-            /**
-             * Having an empty rules object present makes it more obvious to the user where they would
-             * extend things from if they needed to
-             */
-            rules: {},
-        },
-        {
-            files: ['*.ts', '*.tsx'],
-            rules: {},
-        },
-        {
-            files: ['*.js', '*.jsx'],
-            rules: {},
-        },
-    ];
-    if (options.addPackageJsonDependencyChecks ||
-        isBuildableLibraryProject(projectConfig)) {
+    const addDependencyChecks = options.addPackageJsonDependencyChecks ||
+        isBuildableLibraryProject(projectConfig);
+    const overrides = (0, flat_config_1.useFlatConfig)(tree)
+        ? // For flat configs, we don't need to generate different overrides for each file. Users should add their own overrides as needed.
+            []
+        : [
+            {
+                files: ['*.ts', '*.tsx', '*.js', '*.jsx'],
+                /**
+                 * NOTE: We no longer set parserOptions.project by default when creating new projects.
+                 *
+                 * We have observed that users rarely add rules requiring type-checking to their Nx workspaces, and therefore
+                 * do not actually need the capabilites which parserOptions.project provides. When specifying parserOptions.project,
+                 * typescript-eslint needs to create full TypeScript Programs for you. When omitting it, it can perform a simple
+                 * parse (and AST tranformation) of the source files it encounters during a lint run, which is much faster and much
+                 * less memory intensive.
+                 *
+                 * In the rare case that users attempt to add rules requiring type-checking to their setup later on (and haven't set
+                 * parserOptions.project), the executor will attempt to look for the particular error typescript-eslint gives you
+                 * and provide feedback to the user.
+                 */
+                parserOptions: !setParserOptionsProject
+                    ? undefined
+                    : {
+                        project: [`${projectConfig.root}/tsconfig.*?.json`],
+                    },
+                /**
+                 * Having an empty rules object present makes it more obvious to the user where they would
+                 * extend things from if they needed to
+                 */
+                rules: {},
+            },
+            {
+                files: ['*.ts', '*.tsx'],
+                rules: {},
+            },
+            {
+                files: ['*.js', '*.jsx'],
+                rules: {},
+            },
+        ];
+    if (addDependencyChecks) {
         overrides.push({
             files: ['*.json'],
             parser: 'jsonc-eslint-parser',
             rules: {
-                '@nx/dependency-checks': 'error',
+                '@nx/dependency-checks': [
+                    'error',
+                    {
+                        // With flat configs, we don't want to include imports in the eslint js/cjs/mjs files to be checked
+                        ignoredFiles: ['**/*/*eslint*'],
+                    },
+                ],
             },
         });
     }
     if ((0, flat_config_1.useFlatConfig)(tree)) {
-        const isCompatNeeded = addDependencyChecks;
         const nodes = [];
         const importMap = new Map();
         if (extendedRootConfig) {
@@ -172,7 +180,7 @@ function createEsLintConfiguration(tree, options, projectConfig, setParserOption
         overrides.forEach((override) => {
             nodes.push((0, ast_utils_1.generateFlatOverride)(override));
         });
-        const nodeList = (0, ast_utils_1.createNodeList)(importMap, nodes, isCompatNeeded);
+        const nodeList = (0, ast_utils_1.createNodeList)(importMap, nodes);
         const content = (0, ast_utils_1.stringifyNodeList)(nodeList);
         tree.write((0, path_1.join)(projectConfig.root, 'eslint.config.js'), content);
     }

package/src/generators/lint-project/setup-root-eslint.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupRootEsLint = setupRootEsLint;
 const devkit_1 = require("@nx/devkit");
+const flat_config_1 = require("../../utils/flat-config");
 const versions_1 = require("../../utils/versions");
 const global_eslint_config_1 = require("../init/global-eslint-config");
 const eslint_file_1 = require("../utils/eslint-file");
@@ -10,6 +11,12 @@ function setupRootEsLint(tree, options) {
     if (rootEslintFile) {
         return () => { };
     }
+    if (!(0, flat_config_1.useFlatConfig)(tree)) {
+        return setUpLegacyRootEslintRc(tree, options);
+    }
+    return setUpRootFlatConfig(tree, options);
+}
+function setUpLegacyRootEslintRc(tree, options) {
     (0, devkit_1.writeJson)(tree, '.eslintrc.json', (0, global_eslint_config_1.getGlobalEsLintConfiguration)(options.unitTestRunner, options.rootProject));
     if (tree.exists('.eslintignore')) {
         let content = tree.read('.eslintignore', 'utf-8');
@@ -30,3 +37,15 @@ function setupRootEsLint(tree, options) {
         })
         : () => { };
 }
+function setUpRootFlatConfig(tree, options) {
+    tree.write('eslint.config.js', (0, global_eslint_config_1.getGlobalFlatEslintConfiguration)(options.rootProject));
+    return !options.skipPackageJson
+        ? (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@eslint/js': versions_1.eslint9__eslintVersion,
+            '@nx/eslint-plugin': versions_1.nxVersion,
+            eslint: versions_1.eslint9__eslintVersion,
+            'eslint-config-prettier': versions_1.eslintConfigPrettierVersion,
+            'typescript-eslint': versions_1.eslint9__typescriptESLintVersion,
+        })
+        : () => { };
+}

package/src/generators/utils/eslint-file.d.ts

@@ -1,16 +1,23 @@
-import type { Tree } from '@nx/devkit';
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
 import type { Linter } from 'eslint';
 export declare function findEslintFile(tree: Tree, projectRoot?: string): string | null;
 export declare function isEslintConfigSupported(tree: Tree, projectRoot?: string): boolean;
 export declare function updateRelativePathsInConfig(tree: Tree, sourcePath: string, destinationPath: string): void;
-export declare function addOverrideToLintConfig(tree: Tree, root: string, override: Linter.ConfigOverride<Linter.RulesRecord>, options?: {
+export declare function addOverrideToLintConfig(tree: Tree, root: string, override: Partial<Linter.ConfigOverride<Linter.RulesRecord>>, options?: {
     insertAtTheEnd?: boolean;
     checkBaseConfig?: boolean;
 }): void;
 export declare function updateOverrideInLintConfig(tree: Tree, root: string, lookup: (override: Linter.ConfigOverride<Linter.RulesRecord>) => boolean, update: (override: Linter.ConfigOverride<Linter.RulesRecord>) => Linter.ConfigOverride<Linter.RulesRecord>): void;
 export declare function lintConfigHasOverride(tree: Tree, root: string, lookup: (override: Linter.ConfigOverride<Linter.RulesRecord>) => boolean, checkBaseConfig?: boolean): boolean;
 export declare function replaceOverridesInLintConfig(tree: Tree, root: string, overrides: Linter.ConfigOverride<Linter.RulesRecord>[]): void;
-export declare function addExtendsToLintConfig(tree: Tree, root: string, plugin: string | string[]): void;
+export declare function addExtendsToLintConfig(tree: Tree, root: string, plugin: string | {
+    name: string;
+    needCompatFixup: boolean;
+} | Array<string | {
+    name: string;
+    needCompatFixup: boolean;
+}>, insertAtTheEnd?: boolean): GeneratorCallback;
+export declare function addPredefinedConfigToFlatLintConfig(tree: Tree, root: string, predefinedConfigName: string, moduleName?: string, moduleImportPath?: string, spread?: boolean, insertAtTheEnd?: boolean): void;
 export declare function addPluginsToLintConfig(tree: Tree, root: string, plugin: string | string[]): void;
 export declare function addIgnoresToLintConfig(tree: Tree, root: string, ignorePatterns: string[]): void;
 export declare function getPluginImport(pluginName: string): string;

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

@@ -8,14 +8,18 @@ exports.updateOverrideInLintConfig = updateOverrideInLintConfig;
 exports.lintConfigHasOverride = lintConfigHasOverride;
 exports.replaceOverridesInLintConfig = replaceOverridesInLintConfig;
 exports.addExtendsToLintConfig = addExtendsToLintConfig;
+exports.addPredefinedConfigToFlatLintConfig = addPredefinedConfigToFlatLintConfig;
 exports.addPluginsToLintConfig = addPluginsToLintConfig;
 exports.addIgnoresToLintConfig = addIgnoresToLintConfig;
 exports.getPluginImport = getPluginImport;
 const devkit_1 = require("@nx/devkit");
+const semver_1 = require("semver");
+const config_file_1 = require("../../utils/config-file");
 const flat_config_1 = require("../../utils/flat-config");
+const version_utils_1 = require("../../utils/version-utils");
+const versions_1 = require("../../utils/versions");
 const ast_utils_1 = require("./flat-config/ast-utils");
 const path_utils_1 = require("./flat-config/path-utils");
-const config_file_1 = require("../../utils/config-file");
 function findEslintFile(tree, projectRoot) {
     if (projectRoot === undefined && tree.exists(config_file_1.baseEsLintConfigFile)) {
         return config_file_1.baseEsLintConfigFile;
@@ -110,12 +114,12 @@ function addOverrideToLintConfig(tree, root, override, options = {
 }) {
     const isBase = options.checkBaseConfig && findEslintFile(tree, root).includes('.base');
     if ((0, flat_config_1.useFlatConfig)(tree)) {
-        const fileName = (0, devkit_1.joinPathFragments)(root, isBase ? config_file_1.baseEsLintFlatConfigFile : (0, flat_config_1.flatConfigEslintFilename)(tree));
+        const fileName = (0, devkit_1.joinPathFragments)(root, isBase ? config_file_1.baseEsLintFlatConfigFile : (0, flat_config_1.getRootESLintFlatConfigFilename)(tree));
         const flatOverride = (0, ast_utils_1.generateFlatOverride)(override);
         let content = tree.read(fileName, 'utf8');
-        // we will be using compat here so we need to make sure it's added
-        if (overrideNeedsCompat(override)) {
-            content = (0, ast_utils_1.addCompatToFlatConfig)(content);
+        // Check if the provided override using legacy eslintrc properties or plugins, if so we need to add compat
+        if ((0, ast_utils_1.overrideNeedsCompat)(override)) {
+            content = (0, ast_utils_1.addFlatCompatToFlatConfig)(content);
         }
         tree.write(fileName, (0, ast_utils_1.addBlockToFlatConfigExport)(content, flatOverride, options));
     }
@@ -133,12 +137,9 @@ function addOverrideToLintConfig(tree, root, override, options = {
         });
     }
 }
-function overrideNeedsCompat(override) {
-    return (override.env || override.extends || override.plugins || override.parser);
-}
 function updateOverrideInLintConfig(tree, root, lookup, update) {
     if ((0, flat_config_1.useFlatConfig)(tree)) {
-        const fileName = (0, devkit_1.joinPathFragments)(root, (0, flat_config_1.flatConfigEslintFilename)(tree));
+        const fileName = (0, devkit_1.joinPathFragments)(root, (0, flat_config_1.getRootESLintFlatConfigFilename)(tree));
         let content = tree.read(fileName, 'utf8');
         content = (0, ast_utils_1.replaceOverride)(content, root, lookup, update);
         tree.write(fileName, content);
@@ -173,7 +174,7 @@ function lintConfigHasOverride(tree, root, lookup, checkBaseConfig = false) {
     }
     const isBase = checkBaseConfig && findEslintFile(tree, root).includes('.base');
     if ((0, flat_config_1.useFlatConfig)(tree)) {
-        const fileName = (0, devkit_1.joinPathFragments)(root, isBase ? config_file_1.baseEsLintFlatConfigFile : (0, flat_config_1.flatConfigEslintFilename)(tree));
+        const fileName = (0, devkit_1.joinPathFragments)(root, isBase ? config_file_1.baseEsLintFlatConfigFile : (0, flat_config_1.getRootESLintFlatConfigFilename)(tree));
         const content = tree.read(fileName, 'utf8');
         return (0, ast_utils_1.hasOverride)(content, lookup);
     }
@@ -184,11 +185,11 @@ function lintConfigHasOverride(tree, root, lookup, checkBaseConfig = false) {
 }
 function replaceOverridesInLintConfig(tree, root, overrides) {
     if ((0, flat_config_1.useFlatConfig)(tree)) {
-        const fileName = (0, devkit_1.joinPathFragments)(root, (0, flat_config_1.flatConfigEslintFilename)(tree));
+        const fileName = (0, devkit_1.joinPathFragments)(root, (0, flat_config_1.getRootESLintFlatConfigFilename)(tree));
         let content = tree.read(fileName, 'utf8');
-        // we will be using compat here so we need to make sure it's added
-        if (overrides.some(overrideNeedsCompat)) {
-            content = (0, ast_utils_1.addCompatToFlatConfig)(content);
+        // Check if any of the provided overrides using legacy eslintrc properties or plugins, if so we need to add compat
+        if (overrides.some(ast_utils_1.overrideNeedsCompat)) {
+            content = (0, ast_utils_1.addFlatCompatToFlatConfig)(content);
         }
         content = (0, ast_utils_1.removeOverridesFromLintConfig)(content);
         overrides.forEach((override) => {
@@ -205,18 +206,62 @@ function replaceOverridesInLintConfig(tree, root, overrides) {
         });
     }
 }
-function addExtendsToLintConfig(tree, root, plugin) {
-    const plugins = Array.isArray(plugin) ? plugin : [plugin];
+function addExtendsToLintConfig(tree, root, plugin, insertAtTheEnd = false) {
     if ((0, flat_config_1.useFlatConfig)(tree)) {
-        const fileName = (0, devkit_1.joinPathFragments)(root, (0, flat_config_1.flatConfigEslintFilename)(tree));
-        const pluginExtends = (0, ast_utils_1.generatePluginExtendsElement)(plugins);
+        const pluginExtends = [];
+        const fileName = (0, devkit_1.joinPathFragments)(root, (0, flat_config_1.getRootESLintFlatConfigFilename)(tree));
+        let shouldImportEslintCompat = false;
+        // assume eslint version is 9 if not found, as it's what we'd be generating by default
+        const eslintVersion = (0, version_utils_1.getInstalledEslintVersion)(tree) ?? versions_1.eslint9__eslintVersion;
+        if ((0, semver_1.gte)(eslintVersion, '9.0.0')) {
+            // eslint v9 requires the incompatible plugins to be wrapped with a helper from @eslint/compat
+            const plugins = (Array.isArray(plugin) ? plugin : [plugin]).map((p) => typeof p === 'string' ? { name: p, needCompatFixup: false } : p);
+            let compatiblePluginsBatch = [];
+            plugins.forEach(({ name, needCompatFixup }) => {
+                if (needCompatFixup) {
+                    if (compatiblePluginsBatch.length > 0) {
+                        // flush the current batch of compatible plugins and reset it
+                        pluginExtends.push((0, ast_utils_1.generatePluginExtendsElement)(compatiblePluginsBatch));
+                        compatiblePluginsBatch = [];
+                    }
+                    // generate the extends for the incompatible plugin
+                    pluginExtends.push((0, ast_utils_1.generatePluginExtendsElementWithCompatFixup)(name));
+                    shouldImportEslintCompat = true;
+                }
+                else {
+                    // add the compatible plugin to the current batch
+                    compatiblePluginsBatch.push(name);
+                }
+            });
+            if (compatiblePluginsBatch.length > 0) {
+                // flush the batch of compatible plugins
+                pluginExtends.push((0, ast_utils_1.generatePluginExtendsElement)(compatiblePluginsBatch));
+            }
+        }
+        else {
+            const plugins = (Array.isArray(plugin) ? plugin : [plugin]).map((p) => typeof p === 'string' ? p : p.name);
+            pluginExtends.push((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, {
-            insertAtTheEnd: false,
-        }));
+        if (shouldImportEslintCompat) {
+            content = (0, ast_utils_1.addImportToFlatConfig)(content, ['fixupConfigRules'], '@eslint/compat');
+        }
+        content = (0, ast_utils_1.addFlatCompatToFlatConfig)(content);
+        // reverse the order to ensure they are added in the correct order at the
+        // start of the `extends` array
+        for (const pluginExtend of pluginExtends.reverse()) {
+            content = (0, ast_utils_1.addBlockToFlatConfigExport)(content, pluginExtend, {
+                insertAtTheEnd,
+            });
+        }
+        tree.write(fileName, content);
+        if (shouldImportEslintCompat) {
+            return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@eslint/compat': versions_1.eslintCompat }, undefined, true);
+        }
+        return () => { };
     }
     else {
+        const plugins = (Array.isArray(plugin) ? plugin : [plugin]).map((p) => typeof p === 'string' ? p : p.name);
         const fileName = (0, devkit_1.joinPathFragments)(root, '.eslintrc.json');
         (0, devkit_1.updateJson)(tree, fileName, (json) => {
             json.extends ??= [];
@@ -226,12 +271,22 @@ function addExtendsToLintConfig(tree, root, plugin) {
             ];
             return json;
         });
+        return () => { };
     }
 }
+function addPredefinedConfigToFlatLintConfig(tree, root, predefinedConfigName, moduleName = 'nx', moduleImportPath = '@nx/eslint-plugin', spread = true, insertAtTheEnd = true) {
+    if (!(0, flat_config_1.useFlatConfig)(tree))
+        throw new Error('Predefined configs can only be used with flat configs');
+    const fileName = (0, devkit_1.joinPathFragments)(root, (0, flat_config_1.getRootESLintFlatConfigFilename)(tree));
+    let content = tree.read(fileName, 'utf8');
+    content = (0, ast_utils_1.addImportToFlatConfig)(content, moduleName, moduleImportPath);
+    content = (0, ast_utils_1.addBlockToFlatConfigExport)(content, (0, ast_utils_1.generateFlatPredefinedConfig)(predefinedConfigName, moduleName, spread), { insertAtTheEnd });
+    tree.write(fileName, content);
+}
 function addPluginsToLintConfig(tree, root, plugin) {
     const plugins = Array.isArray(plugin) ? plugin : [plugin];
     if ((0, flat_config_1.useFlatConfig)(tree)) {
-        const fileName = (0, devkit_1.joinPathFragments)(root, (0, flat_config_1.flatConfigEslintFilename)(tree));
+        const fileName = (0, devkit_1.joinPathFragments)(root, (0, flat_config_1.getRootESLintFlatConfigFilename)(tree));
         let content = tree.read(fileName, 'utf8');
         const mappedPlugins = [];
         plugins.forEach((name) => {
@@ -255,7 +310,7 @@ function addPluginsToLintConfig(tree, root, plugin) {
 }
 function addIgnoresToLintConfig(tree, root, ignorePatterns) {
     if ((0, flat_config_1.useFlatConfig)(tree)) {
-        const fileName = (0, devkit_1.joinPathFragments)(root, (0, flat_config_1.flatConfigEslintFilename)(tree));
+        const fileName = (0, devkit_1.joinPathFragments)(root, (0, flat_config_1.getRootESLintFlatConfigFilename)(tree));
         const block = (0, ast_utils_1.generateAst)({
             ignores: ignorePatterns.map((path) => (0, path_utils_1.mapFilePath)(path)),
         });

package/src/generators/utils/flat-config/ast-utils.d.ts

@@ -8,7 +8,7 @@ export declare function hasOverride(content: string, lookup: (override: Linter.C
 /**
  * Finds an override matching the lookup function and applies the update function to it
  */
-export declare function replaceOverride(content: string, root: string, lookup: (override: Linter.ConfigOverride<Linter.RulesRecord>) => boolean, update?: (override: Linter.ConfigOverride<Linter.RulesRecord>) => Linter.ConfigOverride<Linter.RulesRecord>): string;
+export declare function replaceOverride(content: string, root: string, lookup: (override: Linter.ConfigOverride<Linter.RulesRecord>) => boolean, update?: (override: Partial<Linter.ConfigOverride<Linter.RulesRecord>>) => Partial<Linter.ConfigOverride<Linter.RulesRecord>>): string;
 /**
  * Adding require statement to the top of the file
  */
@@ -33,14 +33,15 @@ export declare function addPluginsToExportsBlock(content: string, plugins: {
 /**
  * Adds compat if missing to flat config
  */
-export declare function addCompatToFlatConfig(content: string): string;
+export declare function addFlatCompatToFlatConfig(content: string): string;
 /**
  * Generate node list representing the imports and the exports blocks
  * Optionally add flat compat initialization
  */
-export declare function createNodeList(importsMap: Map<string, string>, exportElements: ts.Expression[], isFlatCompatNeeded: boolean): ts.NodeArray<ts.VariableStatement | ts.Identifier | ts.ExpressionStatement | ts.SourceFile>;
+export declare function createNodeList(importsMap: Map<string, string>, exportElements: ts.Expression[]): ts.NodeArray<ts.VariableStatement | ts.Identifier | ts.ExpressionStatement | ts.SourceFile>;
 export declare function generateSpreadElement(name: string): ts.SpreadElement;
 export declare function generatePluginExtendsElement(plugins: string[]): ts.SpreadElement;
+export declare function generatePluginExtendsElementWithCompatFixup(plugin: string): ts.SpreadElement;
 /**
  * Stringifies TS nodes to file content string
  */
@@ -49,12 +50,20 @@ export declare function stringifyNodeList(nodes: ts.NodeArray<ts.VariableStateme
  * generates AST require statement
  */
 export declare function generateRequire(variableName: string | ts.ObjectBindingPattern, imp: string): ts.VariableStatement;
+export declare function overrideNeedsCompat(override: Partial<Linter.ConfigOverride<Linter.RulesRecord>>): string | string[] | {
+    [name: string]: boolean;
+};
 /**
- * Generates AST object or spread element based on JSON override object
+ * Generates an AST object or spread element representing a modern flat config entry,
+ * based on a given legacy eslintrc JSON override object
  */
-export declare function generateFlatOverride(override: Linter.ConfigOverride<Linter.RulesRecord>): ts.ObjectLiteralExpression | ts.SpreadElement;
-export declare function mapFilePaths(override: Linter.ConfigOverride<Linter.RulesRecord>): void;
+export declare function generateFlatOverride(_override: Partial<Linter.ConfigOverride<Linter.RulesRecord>>): ts.ObjectLiteralExpression | ts.SpreadElement;
+export declare function generateFlatPredefinedConfig(predefinedConfigName: string, moduleName?: string, spread?: boolean): ts.ObjectLiteralExpression | ts.SpreadElement | ts.ElementAccessExpression;
+export declare function mapFilePaths(_override: Partial<Linter.ConfigOverride<Linter.RulesRecord>>): Partial<Linter.ConfigOverride<Linter.RulesRecord>>;
 /**
  * Generates an AST from a JSON-type input
  */
-export declare function generateAst<T>(input: unknown): T;
+export declare function generateAst<T>(input: unknown, propertyAssignmentReplacer?: {
+    keyToMatch: RegExp | string;
+    replacer: (propertyAssignment: ts.PropertyAssignment, propertyName: string) => ts.PropertyAssignment;
+}): T;

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

@@ -8,13 +8,16 @@ exports.addBlockToFlatConfigExport = addBlockToFlatConfigExport;
 exports.removePlugin = removePlugin;
 exports.removeCompatExtends = removeCompatExtends;
 exports.addPluginsToExportsBlock = addPluginsToExportsBlock;
-exports.addCompatToFlatConfig = addCompatToFlatConfig;
+exports.addFlatCompatToFlatConfig = addFlatCompatToFlatConfig;
 exports.createNodeList = createNodeList;
 exports.generateSpreadElement = generateSpreadElement;
 exports.generatePluginExtendsElement = generatePluginExtendsElement;
+exports.generatePluginExtendsElementWithCompatFixup = generatePluginExtendsElementWithCompatFixup;
 exports.stringifyNodeList = stringifyNodeList;
 exports.generateRequire = generateRequire;
+exports.overrideNeedsCompat = overrideNeedsCompat;
 exports.generateFlatOverride = generateFlatOverride;
+exports.generateFlatPredefinedConfig = generateFlatPredefinedConfig;
 exports.mapFilePaths = mapFilePaths;
 exports.generateAst = generateAst;
 const devkit_1 = require("@nx/devkit");
@@ -86,10 +89,7 @@ function hasOverride(content, lookup) {
                 // strip any spread elements
                 objSource = fullNodeText.replace(SPREAD_ELEMENTS_REGEXP, '');
             }
-            const data = (0, devkit_1.parseJson)(objSource
-                // ensure property names have double quotes so that JSON.parse works
-                .replace(/'/g, '"')
-                .replace(/\s([a-zA-Z0-9_]+)\s*:/g, ' "$1": '));
+            const data = parseTextToJson(objSource);
             if (lookup(data)) {
                 return true;
             }
@@ -101,7 +101,9 @@ function parseTextToJson(text) {
     return (0, devkit_1.parseJson)(text
         // ensure property names have double quotes so that JSON.parse works
         .replace(/'/g, '"')
-        .replace(/\s([a-zA-Z0-9_]+)\s*:/g, ' "$1": '));
+        .replace(/\s([a-zA-Z0-9_]+)\s*:/g, ' "$1": ')
+        // stringify any require calls to avoid JSON parsing errors, turn them into just the string value being required
+        .replace(/require\(['"]([^'"]+)['"]\)/g, '"$1"'));
 }
 /**
  * Finds an override matching the lookup function and applies the update function to it
@@ -138,13 +140,18 @@ function replaceOverride(content, root, lookup, update) {
                     start,
                     length: end - start,
                 });
-                const updatedData = update(data);
+                let updatedData = update(data);
                 if (updatedData) {
-                    mapFilePaths(updatedData);
+                    updatedData = mapFilePaths(updatedData);
                     changes.push({
                         type: devkit_1.ChangeType.Insert,
                         index: start,
-                        text: JSON.stringify(updatedData, null, 2).slice(2, -2), // remove curly braces and start/end line breaks since we are injecting just properties
+                        text: JSON.stringify(updatedData, null, 2)
+                            // restore any parser require calls that were stripped during JSON parsing
+                            .replace(/"parser": "([^"]+)"/g, (_, parser) => {
+                            return `"parser": require('${parser}')`;
+                        })
+                            .slice(2, -2), // remove curly braces and start/end line breaks since we are injecting just properties
                     });
                 }
             }
@@ -404,7 +411,7 @@ function removeCompatExtends(content, compatExtends) {
                     type: devkit_1.ChangeType.Insert,
                     index: node.pos,
                     text: '\n' +
-                        body.replace(new RegExp('[ \t]s*...' + paramName + '[ \t]*,?\\s*', 'g'), ''),
+                        body.replace(new RegExp('[ \t]s*...' + paramName + '(\\.rules)?[ \t]*,?\\s*', 'g'), ''),
                 });
             }
         }
@@ -427,7 +434,7 @@ function addPluginsToExportsBlock(content, plugins) {
 /**
  * Adds compat if missing to flat config
  */
-function addCompatToFlatConfig(content) {
+function addFlatCompatToFlatConfig(content) {
     let result = content;
     result = addImportToFlatConfig(result, 'js', '@eslint/js');
     if (result.includes('const compat = new FlatCompat')) {
@@ -439,28 +446,21 @@ function addCompatToFlatConfig(content) {
         {
             type: devkit_1.ChangeType.Insert,
             index: index - 1,
-            text: `${DEFAULT_FLAT_CONFIG}\n`,
+            text: `
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+});
+`,
         },
     ]);
 }
-const DEFAULT_FLAT_CONFIG = `
-const compat = new FlatCompat({
-      baseDirectory: __dirname,
-      recommendedConfig: js.configs.recommended,
-    });
-  `;
 /**
  * Generate node list representing the imports and the exports blocks
  * Optionally add flat compat initialization
  */
-function createNodeList(importsMap, exportElements, isFlatCompatNeeded) {
+function createNodeList(importsMap, exportElements) {
     const importsList = [];
-    if (isFlatCompatNeeded) {
-        importsMap.set('@eslint/js', 'js');
-        importsList.push(generateRequire(ts.factory.createObjectBindingPattern([
-            ts.factory.createBindingElement(undefined, undefined, 'FlatCompat'),
-        ]), '@eslint/eslintrc'));
-    }
     // generateRequire(varName, imp, ts.factory);
     Array.from(importsMap.entries()).forEach(([imp, varName]) => {
         importsList.push(generateRequire(varName, imp));
@@ -468,7 +468,7 @@ function createNodeList(importsMap, exportElements, isFlatCompatNeeded) {
     return ts.factory.createNodeArray([
         // add plugin imports
         ...importsList,
-        ts.createSourceFile('', isFlatCompatNeeded ? DEFAULT_FLAT_CONFIG : '', ts.ScriptTarget.Latest, false, ts.ScriptKind.JS),
+        ts.createSourceFile('', '', ts.ScriptTarget.Latest, false, ts.ScriptKind.JS),
         // creates:
         // module.exports = [ ... ];
         ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('module'), ts.factory.createIdentifier('exports')), ts.factory.createToken(ts.SyntaxKind.EqualsToken), ts.factory.createArrayLiteralExpression(exportElements, true))),
@@ -480,6 +480,11 @@ function generateSpreadElement(name) {
 function generatePluginExtendsElement(plugins) {
     return ts.factory.createSpreadElement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('compat'), ts.factory.createIdentifier('extends')), undefined, plugins.map((plugin) => ts.factory.createStringLiteral(plugin))));
 }
+function generatePluginExtendsElementWithCompatFixup(plugin) {
+    return ts.factory.createSpreadElement(ts.factory.createCallExpression(ts.factory.createIdentifier('fixupConfigRules'), undefined, [
+        ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('compat'), ts.factory.createIdentifier('extends')), undefined, [ts.factory.createStringLiteral(plugin)]),
+    ]));
+}
 /**
  * Stringifies TS nodes to file content string
  */
@@ -502,21 +507,95 @@ function generateRequire(variableName, imp) {
     ], ts.NodeFlags.Const));
 }
 /**
- * Generates AST object or spread element based on JSON override object
+ * FROM: https://github.com/eslint/rewrite/blob/e2a7ec809db20e638abbad250d105ddbde88a8d5/packages/migrate-config/src/migrate-config.js#L222
+ *
+ * Converts a glob pattern to a format that can be used in a flat config.
+ * @param {string} pattern The glob pattern to convert.
+ * @returns {string} The converted glob pattern.
  */
-function generateFlatOverride(override) {
-    mapFilePaths(override);
-    if (!override.env &&
-        !override.extends &&
-        !override.plugins &&
-        !override.parser) {
-        if (override.parserOptions) {
-            const { parserOptions, ...rest } = override;
-            return generateAst({ ...rest, languageOptions: { parserOptions } });
+function convertGlobPattern(pattern) {
+    const isNegated = pattern.startsWith('!');
+    const patternToTest = isNegated ? pattern.slice(1) : pattern;
+    // if the pattern is already in the correct format, return it
+    if (patternToTest === '**' || patternToTest.includes('/')) {
+        return pattern;
+    }
+    return `${isNegated ? '!' : ''}**/${patternToTest}`;
+}
+// FROM: https://github.com/eslint/rewrite/blob/e2a7ec809db20e638abbad250d105ddbde88a8d5/packages/migrate-config/src/migrate-config.js#L38
+const keysToCopy = ['settings', 'rules', 'processor'];
+function overrideNeedsCompat(override) {
+    return override.env || override.extends || override.plugins;
+}
+/**
+ * Generates an AST object or spread element representing a modern flat config entry,
+ * based on a given legacy eslintrc JSON override object
+ */
+function generateFlatOverride(_override) {
+    const override = mapFilePaths(_override);
+    // We do not need the compat tooling for this override
+    if (!overrideNeedsCompat(override)) {
+        // Ensure files is an array
+        let files = override.files;
+        if (typeof files === 'string') {
+            files = [files];
+        }
+        const flatConfigOverride = {
+            files,
+        };
+        if (override.rules) {
+            flatConfigOverride.rules = override.rules;
+        }
+        // Copy over everything that stays the same
+        keysToCopy.forEach((key) => {
+            if (override[key]) {
+                flatConfigOverride[key] = override[key];
+            }
+        });
+        if (override.parser || override.parserOptions) {
+            const languageOptions = {};
+            if (override.parser) {
+                languageOptions['parser'] = override.parser;
+            }
+            if (override.parserOptions) {
+                languageOptions['parserOptions'] = override.parserOptions;
+            }
+            if (Object.keys(languageOptions).length) {
+                flatConfigOverride.languageOptions = languageOptions;
+            }
         }
-        return generateAst(override);
+        if (override['languageOptions']) {
+            flatConfigOverride.languageOptions = override['languageOptions'];
+        }
+        if (override.excludedFiles) {
+            flatConfigOverride.ignores = (Array.isArray(override.excludedFiles)
+                ? override.excludedFiles
+                : [override.excludedFiles]).map((p) => convertGlobPattern(p));
+        }
+        return generateAst(flatConfigOverride, {
+            keyToMatch: /^(parser|rules)$/,
+            replacer: (propertyAssignment, propertyName) => {
+                if (propertyName === 'rules') {
+                    // Add comment that user can override rules if there are no overrides.
+                    if (ts.isObjectLiteralExpression(propertyAssignment.initializer) &&
+                        propertyAssignment.initializer.properties.length === 0) {
+                        return ts.addSyntheticLeadingComment(ts.factory.createPropertyAssignment(propertyAssignment.name, ts.factory.createObjectLiteralExpression([])), ts.SyntaxKind.SingleLineCommentTrivia, ' Override or add rules here');
+                    }
+                    return propertyAssignment;
+                }
+                else {
+                    // Change parser to require statement.
+                    return ts.factory.createPropertyAssignment('parser', ts.factory.createCallExpression(ts.factory.createIdentifier('require'), undefined, [
+                        ts.factory.createStringLiteral(override['languageOptions']?.['parserOptions']?.parser ??
+                            override['languageOptions']?.parser ??
+                            override.parser),
+                    ]));
+                }
+            },
+        });
     }
-    const { files, excludedFiles, rules, parserOptions, ...rest } = override;
+    // At this point we are applying the flat config compat tooling to the override
+    const { excludedFiles, parser, parserOptions, rules, files, ...rest } = override;
     const objectLiteralElements = [
         ts.factory.createSpreadAssignment(ts.factory.createIdentifier('config')),
     ];
@@ -543,7 +622,14 @@ function generateFlatOverride(override) {
         ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createParenthesizedExpression(ts.factory.createObjectLiteralExpression(objectLiteralElements, true))),
     ]));
 }
-function mapFilePaths(override) {
+function generateFlatPredefinedConfig(predefinedConfigName, moduleName = 'nx', spread = true) {
+    const node = ts.factory.createElementAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(moduleName), ts.factory.createIdentifier('configs')), ts.factory.createStringLiteral(predefinedConfigName));
+    return spread ? ts.factory.createSpreadElement(node) : node;
+}
+function mapFilePaths(_override) {
+    const override = {
+        ..._override,
+    };
     if (override.files) {
         override.files = Array.isArray(override.files)
             ? override.files
@@ -556,6 +642,7 @@ function mapFilePaths(override) {
             : [override.excludedFiles];
         override.excludedFiles = override.excludedFiles.map((file) => (0, path_utils_1.mapFilePath)(file));
     }
+    return override;
 }
 function addTSObjectProperty(elements, key, value) {
     if (value) {
@@ -565,18 +652,16 @@ function addTSObjectProperty(elements, key, value) {
 /**
  * Generates an AST from a JSON-type input
  */
-function generateAst(input) {
+function generateAst(input, propertyAssignmentReplacer) {
     if (Array.isArray(input)) {
-        return ts.factory.createArrayLiteralExpression(input.map((item) => generateAst(item)), input.length > 1 // multiline only if more than one item
+        return ts.factory.createArrayLiteralExpression(input.map((item) => generateAst(item, propertyAssignmentReplacer)), input.length > 1 // multiline only if more than one item
         );
     }
     if (input === null) {
         return ts.factory.createNull();
     }
     if (typeof input === 'object') {
-        return ts.factory.createObjectLiteralExpression(Object.entries(input)
-            .filter(([_, value]) => value !== undefined)
-            .map(([key, value]) => ts.factory.createPropertyAssignment(isValidKey(key) ? key : ts.factory.createStringLiteral(key), generateAst(value))), Object.keys(input).length > 1 // multiline only if more than one property
+        return ts.factory.createObjectLiteralExpression(generatePropertyAssignmentsFromObjectEntries(input, propertyAssignmentReplacer), Object.keys(input).length > 1 // multiline only if more than one property
         );
     }
     if (typeof input === 'string') {
@@ -591,6 +676,20 @@ function generateAst(input) {
     // since we are parsing JSON, this should never happen
     throw new Error(`Unknown type: ${typeof input} `);
 }
+function generatePropertyAssignmentsFromObjectEntries(input, propertyAssignmentReplacer) {
+    return Object.entries(input)
+        .filter(([_, value]) => value !== undefined)
+        .map(([key, value]) => {
+        const original = ts.factory.createPropertyAssignment(isValidKey(key) ? key : ts.factory.createStringLiteral(key), generateAst(value, propertyAssignmentReplacer));
+        if (propertyAssignmentReplacer &&
+            (typeof propertyAssignmentReplacer.keyToMatch === 'string'
+                ? key === propertyAssignmentReplacer.keyToMatch
+                : propertyAssignmentReplacer.keyToMatch.test(key))) {
+            return propertyAssignmentReplacer.replacer(original, key);
+        }
+        return original;
+    });
+}
 function isValidKey(key) {
     return /^[a-zA-Z0-9_]+$/.test(key);
 }

package/src/plugins/plugin.js

@@ -47,7 +47,9 @@ const internalCreateNodes = async (configFilePath, options, context, projectsCac
     // dedupe and sort project roots by depth for more efficient traversal
     const dedupedProjectRoots = Array.from(new Set(projectFiles.map((f) => (0, posix_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 ESLint = await (0, resolve_eslint_class_1.resolveESLintClass)({
+        useFlatConfigOverrideVal: (0, config_file_1.isFlatConfig)(configFilePath),
+    });
     const eslintVersion = ESLint.version;
     const projects = {};
     await Promise.all(dedupedProjectRoots.map(async (childProjectRoot, index) => {
@@ -94,10 +96,11 @@ const internalCreateNodes = async (configFilePath, options, context, projectsCac
         projects,
     };
 };
-let collectingLintableFilesPromise;
-const internalCreateNodesV2 = async (configFilePath, options, context, eslintConfigFiles, allProjectRoots, projectRootsByEslintRoots, lintableFilesPerProjectRoot, projectsCache) => {
+const internalCreateNodesV2 = async (configFilePath, options, context, eslintConfigFiles, projectRootsByEslintRoots, lintableFilesPerProjectRoot, projectsCache) => {
     const configDir = (0, posix_1.dirname)(configFilePath);
-    const ESLint = await (0, resolve_eslint_class_1.resolveESLintClass)((0, config_file_1.isFlatConfig)(configFilePath));
+    const ESLint = await (0, resolve_eslint_class_1.resolveESLintClass)({
+        useFlatConfigOverrideVal: (0, config_file_1.isFlatConfig)(configFilePath),
+    });
     const eslintVersion = ESLint.version;
     const projects = {};
     await Promise.all(projectRootsByEslintRoots.get(configDir).map(async (projectRoot) => {
@@ -112,11 +115,6 @@ const internalCreateNodesV2 = async (configFilePath, options, context, eslintCon
             Object.assign(projects, projectsCache[hash]);
             return;
         }
-        if (!lintableFilesPerProjectRoot.size) {
-            collectingLintableFilesPromise ??= collectLintableFilesByProjectRoot(lintableFilesPerProjectRoot, allProjectRoots, options, context);
-            await collectingLintableFilesPromise;
-            collectingLintableFilesPromise = null;
-        }
         const eslint = new ESLint({
             cwd: (0, posix_1.join)(context.workspaceRoot, projectRoot),
         });
@@ -155,9 +153,9 @@ exports.createNodesV2 = [
         const cachePath = (0, posix_1.join)(cache_directory_1.workspaceDataDirectory, `eslint-${optionsHash}.hash`);
         const targetsCache = readTargetsCache(cachePath);
         const { eslintConfigFiles, projectRoots, projectRootsByEslintRoots } = splitConfigFiles(configFiles);
-        const lintableFilesPerProjectRoot = new Map();
+        const lintableFilesPerProjectRoot = await collectLintableFilesByProjectRoot(projectRoots, options, context);
         try {
-            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => internalCreateNodesV2(configFile, options, context, eslintConfigFiles, projectRoots, projectRootsByEslintRoots, lintableFilesPerProjectRoot, targetsCache), eslintConfigFiles, options, context);
+            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => internalCreateNodesV2(configFile, options, context, eslintConfigFiles, projectRootsByEslintRoots, lintableFilesPerProjectRoot, targetsCache), eslintConfigFiles, options, context);
         }
         finally {
             writeTargetsToCache(cachePath, targetsCache);
@@ -203,7 +201,8 @@ function groupProjectRootsByEslintRoots(eslintConfigFiles, projectRoots) {
     }
     return projectRootsByEslintRoots;
 }
-async function collectLintableFilesByProjectRoot(lintableFilesPerProjectRoot, projectRoots, options, context) {
+async function collectLintableFilesByProjectRoot(projectRoots, options, context) {
+    const lintableFilesPerProjectRoot = new Map();
     const lintableFiles = await (0, workspace_context_1.globWithWorkspaceContext)(context.workspaceRoot, [
         `**/*.{${options.extensions.join(',')}}`,
     ]);
@@ -216,6 +215,7 @@ async function collectLintableFilesByProjectRoot(lintableFilesPerProjectRoot, pr
             lintableFilesPerProjectRoot.get(projectRoot).push(file);
         }
     }
+    return lintableFilesPerProjectRoot;
 }
 function getRootForDirectory(directory, roots) {
     let currentPath = (0, posix_1.normalize)(directory);

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

@@ -1,4 +1,4 @@
 import { Tree } from '@nx/devkit';
 export declare const eslintFlatConfigFilenames: string[];
-export declare function flatConfigEslintFilename(tree: Tree): string;
-export declare function useFlatConfig(tree: Tree): boolean;
+export declare function getRootESLintFlatConfigFilename(tree: Tree): string;
+export declare function useFlatConfig(tree?: Tree): boolean;

package/src/utils/flat-config.js

@@ -1,26 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.eslintFlatConfigFilenames = void 0;
-exports.flatConfigEslintFilename = flatConfigEslintFilename;
+exports.getRootESLintFlatConfigFilename = getRootESLintFlatConfigFilename;
 exports.useFlatConfig = useFlatConfig;
+const semver_1 = require("semver");
 // todo: add support for eslint.config.mjs,
 exports.eslintFlatConfigFilenames = [
     'eslint.config.js',
     'eslint.config.cjs',
 ];
-function flatConfigEslintFilename(tree) {
+function getRootESLintFlatConfigFilename(tree) {
     for (const file of exports.eslintFlatConfigFilenames) {
         if (tree.exists(file)) {
             return file;
         }
     }
-    throw new Error('Could not find flat config file');
+    throw new Error('Could not find root flat config file');
 }
 function useFlatConfig(tree) {
+    // Prioritize taking ESLint's own environment variable into account when determining if we should use flat config
+    // If it is not defined, then default to true.
+    if (process.env.ESLINT_USE_FLAT_CONFIG === 'true') {
+        return true;
+    }
+    else if (process.env.ESLINT_USE_FLAT_CONFIG === 'false') {
+        return false;
+    }
+    // If we find an existing flat config file in the root of the provided tree, we should use flat config
+    if (tree) {
+        const hasRootFlatConfig = exports.eslintFlatConfigFilenames.some((filename) => tree.exists(filename));
+        if (hasRootFlatConfig) {
+            return true;
+        }
+    }
+    // Otherwise fallback to checking the installed eslint version
     try {
-        return !!flatConfigEslintFilename(tree);
+        const { ESLint } = require('eslint');
+        // Default to any v8 version to compare against in this case as it implies a much older version of ESLint was found (and gte() requires a valid version)
+        const eslintVersion = ESLint.version || '8.0.0';
+        return (0, semver_1.gte)(eslintVersion, '9.0.0');
     }
     catch {
-        return false;
+        // Default to assuming flat config in case ESLint is not yet installed
+        return true;
     }
 }

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

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

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

@@ -1,22 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveESLintClass = resolveESLintClass;
-async function resolveESLintClass(useFlatConfig = false) {
+const flat_config_1 = require("../utils/flat-config");
+async function resolveESLintClass(opts) {
     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;
+        // Explicitly use the FlatESLint and LegacyESLint classes here because the ESLint class points at a different one based on ESLint v8 vs ESLint v9
+        // But the decision on which one to use is not just based on the major version of ESLint.
+        // @ts-expect-error The may be wrong based on our installed eslint version
+        const { LegacyESLint, FlatESLint } = await Promise.resolve().then(() => require('eslint/use-at-your-own-risk'));
+        const shouldESLintUseFlatConfig = typeof opts?.useFlatConfigOverrideVal === 'boolean'
+            ? opts.useFlatConfigOverrideVal
+            : (0, flat_config_1.useFlatConfig)();
+        return shouldESLintUseFlatConfig ? FlatESLint : LegacyESLint;
     }
     catch {
-        throw new Error('Unable to find ESLint. Ensure ESLint is installed.');
+        throw new Error('Unable to find `eslint`. Ensure a valid `eslint` version is installed.');
     }
 }

package/src/utils/version-utils.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function getInstalledEslintVersion(tree?: Tree): string | null;

package/src/utils/version-utils.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInstalledEslintVersion = getInstalledEslintVersion;
+const devkit_1 = require("@nx/devkit");
+const semver_1 = require("@nx/devkit/src/utils/semver");
+const devkit_internals_1 = require("nx/src/devkit-internals");
+function getInstalledEslintVersion(tree) {
+    try {
+        const eslintPackageJson = (0, devkit_internals_1.readModulePackageJson)('eslint').packageJson;
+        return eslintPackageJson.version;
+    }
+    catch { }
+    // eslint is not installed on disk, it could be in the package.json
+    // but waiting to be installed
+    const rootPackageJson = tree
+        ? (0, devkit_1.readJson)(tree, 'package.json')
+        : (0, devkit_1.readJsonFile)('package.json');
+    const eslintVersionInRootPackageJson = rootPackageJson.devDependencies?.['eslint'] ??
+        rootPackageJson.dependencies?.['eslint'];
+    if (!eslintVersionInRootPackageJson) {
+        // eslint is not installed
+        return null;
+    }
+    try {
+        // try to parse and return the version
+        return (0, semver_1.checkAndCleanWithSemver)('eslint', eslintVersionInRootPackageJson);
+    }
+    catch { }
+    // we could not resolve the version
+    return null;
+}

package/src/utils/versions.d.ts

@@ -3,3 +3,6 @@ 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 = "^7.16.0";
+export declare const eslint9__typescriptESLintVersion = "^8.0.0";
+export declare const eslint9__eslintVersion = "^9.8.0";
+export declare const eslintCompat = "^1.1.1";

package/src/utils/versions.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.typescriptESLintVersion = exports.eslintConfigPrettierVersion = exports.eslintrcVersion = exports.eslintVersion = exports.nxVersion = void 0;
+exports.eslintCompat = exports.eslint9__eslintVersion = exports.eslint9__typescriptESLintVersion = exports.typescriptESLintVersion = exports.eslintConfigPrettierVersion = exports.eslintrcVersion = exports.eslintVersion = exports.nxVersion = void 0;
 exports.nxVersion = require('../../package.json').version;
 exports.eslintVersion = '~8.57.0';
 exports.eslintrcVersion = '^2.1.1';
 exports.eslintConfigPrettierVersion = '^9.0.0';
 exports.typescriptESLintVersion = '^7.16.0';
+// Updated linting stack for ESLint v9, typescript-eslint v8
+exports.eslint9__typescriptESLintVersion = '^8.0.0';
+exports.eslint9__eslintVersion = '^9.8.0';
+exports.eslintCompat = '^1.1.1';