@nx/eslint 0.0.0-pr-30715-a5f5e3b → 0.0.0-pr-31222-862e973

package/src/generators/utils/linter.d.ts

@@ -1,6 +1,3 @@
-/**
- * @deprecated Use LinterType instead. It will be removed in Nx v22.
- */
 export declare enum Linter {
     EsLint = "eslint",
     None = "none"

package/src/generators/utils/linter.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Linter = void 0;
-/**
- * @deprecated Use LinterType instead. It will be removed in Nx v22.
+/*
+ * @deprecated Use LinterType instead
  */
 var Linter;
 (function (Linter) {

package/src/generators/workspace-rule/files/__name__.spec.ts__tmpl__

@@ -1,19 +1,10 @@
-<% if (flatConfig) { %>import { RuleTester } from '@typescript-eslint/rule-tester';
-import type { RuleTesterConfig } from '@typescript-eslint/rule-tester';
-import { rule, RULE_NAME } from './<%= name %>';
-
-const ruleTester = new RuleTester({
-  languageOptions: {
-    parser: require('@typescript-eslint/parser'),
-  },
-} as RuleTesterConfig);
-<% } else { %>import { TSESLint } from '@typescript-eslint/utils';
+import { TSESLint } from '@typescript-eslint/utils';
 import { rule, RULE_NAME } from './<%= name %>';
 
 const ruleTester = new TSESLint.RuleTester({
   parser: require.resolve('@typescript-eslint/parser'),
 });
-<% } %>
+
 ruleTester.run(RULE_NAME, rule, {
   valid: [`const example = true;`],
   invalid: [],

package/src/generators/workspace-rule/workspace-rule.d.ts

@@ -1,6 +1,6 @@
-import { GeneratorCallback, Tree } from '@nx/devkit';
+import { Tree } from '@nx/devkit';
 export interface LintWorkspaceRuleGeneratorOptions {
     name: string;
     directory: string;
 }
-export declare function lintWorkspaceRuleGenerator(tree: Tree, options: LintWorkspaceRuleGeneratorOptions): Promise<GeneratorCallback>;
+export declare function lintWorkspaceRuleGenerator(tree: Tree, options: LintWorkspaceRuleGeneratorOptions): Promise<import("@nx/devkit").GeneratorCallback>;

package/src/generators/workspace-rule/workspace-rule.js

@@ -7,27 +7,19 @@ const path_1 = require("path");
 const ts = require("typescript");
 const workspace_lint_rules_1 = require("../../utils/workspace-lint-rules");
 const workspace_rules_project_1 = require("../workspace-rules-project/workspace-rules-project");
-const flat_config_1 = require("../../utils/flat-config");
-const versions_1 = require("../../utils/versions");
 async function lintWorkspaceRuleGenerator(tree, options) {
-    const tasks = [];
-    const flatConfig = (0, flat_config_1.useFlatConfig)(tree);
     const nxJson = (0, devkit_1.readNxJson)(tree);
     // Ensure that the workspace rules project has been created
-    tasks.push(await (0, workspace_rules_project_1.lintWorkspaceRulesProjectGenerator)(tree, {
+    const projectGeneratorCallback = await (0, workspace_rules_project_1.lintWorkspaceRulesProjectGenerator)(tree, {
         skipFormat: true,
         addPlugin: process.env.NX_ADD_PLUGINS !== 'false' &&
             nxJson.useInferencePlugins !== false,
-    }));
-    if (flatConfig) {
-        tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@typescript-eslint/rule-tester': versions_1.eslint9__typescriptESLintVersion }));
-    }
+    });
     const ruleDir = (0, devkit_1.joinPathFragments)(workspace_lint_rules_1.workspaceLintPluginDir, options.directory ?? '');
     // Generate the required files for the new rule
     (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, 'files'), ruleDir, {
         tmpl: '',
         name: options.name,
-        flatConfig,
     });
     const nameCamelCase = (0, string_utils_1.camelize)(options.name);
     /**
@@ -81,5 +73,5 @@ async function lintWorkspaceRuleGenerator(tree, options) {
          "@nx/workspace-${options.name}": "error"
        }
 `);
-    return (0, devkit_1.runTasksInSerial)(...tasks);
+    return projectGeneratorCallback;
 }

package/src/generators/workspace-rules-project/workspace-rules-project.js

@@ -5,7 +5,6 @@ exports.lintWorkspaceRulesProjectGenerator = lintWorkspaceRulesProjectGenerator;
 const devkit_1 = require("@nx/devkit");
 const js_1 = require("@nx/js");
 const add_swc_dependencies_1 = require("@nx/js/src/utils/swc/add-swc-dependencies");
-const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
 const path_1 = require("path");
 const versions_1 = require("../../utils/versions");
 const workspace_lint_rules_1 = require("../../utils/workspace-lint-rules");
@@ -48,13 +47,11 @@ async function lintWorkspaceRulesProjectGenerator(tree, options = {}) {
         supportTsx: false,
         skipSerializers: true,
         setupFile: 'none',
-        compiler: (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree) ? 'swc' : 'tsc',
+        compiler: 'tsc',
         skipFormat: true,
-        testEnvironment: 'node',
     }));
     (0, devkit_1.updateJson)(tree, (0, path_1.join)(workspace_lint_rules_1.workspaceLintPluginDir, 'tsconfig.spec.json'), (json) => {
         delete json.compilerOptions?.module;
-        delete json.compilerOptions?.moduleResolution;
         if (json.include) {
             json.include = json.include.map((v) => {
                 if (v.startsWith('src/**')) {

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.d.ts

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

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = replacePackage;
+const devkit_1 = require("@nx/devkit");
+const replace_package_1 = require("@nx/devkit/src/utils/replace-package");
+async function replacePackage(tree) {
+    await (0, replace_package_1.replaceNrwlPackageWithNxPackage)(tree, '@nrwl/linter', '@nx/linter');
+    await (0, devkit_1.formatFiles)(tree);
+}

package/src/migrations/update-16-8-0-add-ignored-files/update-16-8-0-add-ignored-files.d.ts

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

package/src/migrations/update-16-8-0-add-ignored-files/update-16-8-0-add-ignored-files.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const eslint_file_1 = require("../../generators/utils/eslint-file");
+// Add `ignoredFiles` pattern to projects using vite, esbuild, and rollup.
+// This is needed because the @nx/dependency-checks lint rule will complain
+// about dependencies used in build config files, even though they are not
+// production dependencies.
+function update(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    const addIgnorePattern = (ignorePattern) => (_options, projectName) => {
+        const project = projects.get(projectName);
+        if (!(0, eslint_file_1.findEslintFile)(tree, project.root) ||
+            !(0, eslint_file_1.isEslintConfigSupported)(tree)) {
+            return;
+        }
+        if ((0, eslint_file_1.lintConfigHasOverride)(tree, project.root, (o) => Array.isArray(o.files)
+            ? o.files.some((f) => f.match(/\.json$/))
+            : !!o.files?.match(/\.json$/), true)) {
+            (0, eslint_file_1.updateOverrideInLintConfig)(tree, project.root, (o) => !!o.rules?.['@nx/dependency-checks'], (o) => {
+                const value = o.rules['@nx/dependency-checks'];
+                let ruleSeverity;
+                let ruleOptions;
+                if (Array.isArray(value)) {
+                    ruleSeverity = value[0];
+                    ruleOptions = value[1];
+                }
+                else {
+                    ruleSeverity = value;
+                    ruleOptions = {};
+                }
+                ruleOptions.ignoredFiles = [ignorePattern];
+                o.rules['@nx/dependency-checks'] = [ruleSeverity, ruleOptions];
+                return o;
+            });
+        }
+    };
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/vite:build', addIgnorePattern('{projectRoot}/vite.config.{js,ts,mjs,mts}'));
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/vite:test', addIgnorePattern('{projectRoot}/vite.config.{js,ts,mjs,mts}'));
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/esbuild:esbuild', addIgnorePattern('{projectRoot}/esbuild.config.{js,ts,mjs,mts}'));
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/rollup:rollup', addIgnorePattern('{projectRoot}/rollup.config.{js,ts,mjs,mts}'));
+}

package/src/migrations/update-17-0-0-rename-to-eslint/update-17-0-0-rename-to-eslint.d.ts

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

package/src/migrations/update-17-0-0-rename-to-eslint/update-17-0-0-rename-to-eslint.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = replacePackage;
+const devkit_1 = require("@nx/devkit");
+const replace_package_1 = require("@nx/devkit/src/utils/replace-package");
+async function replacePackage(tree) {
+    await (0, replace_package_1.replaceNrwlPackageWithNxPackage)(tree, '@nx/linter', '@nx/eslint');
+    // executor name change from :eslint to :lint
+    updateNxJsonExecutor(tree);
+    updateProjectExecutor(tree);
+    await (0, devkit_1.formatFiles)(tree);
+}
+function updateNxJsonExecutor(tree) {
+    if (!tree.exists('nx.json')) {
+        return;
+    }
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    let needsUpdate = false;
+    for (const [targetName, targetConfig] of Object.entries(nxJson.targetDefaults ?? {})) {
+        // this will be in a broken state after the package is globally renamed
+        if (targetConfig.executor !== '@nx/eslint:eslint') {
+            continue;
+        }
+        needsUpdate = true;
+        nxJson.targetDefaults[targetName].executor = '@nx/eslint:lint';
+    }
+    if (needsUpdate) {
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+}
+function updateProjectExecutor(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    for (const [projectName, projectConfiguration] of projects) {
+        let needsUpdate = false;
+        for (const [targetName, targetConfig] of Object.entries(projectConfiguration.targets ?? {})) {
+            // this will be in a broken state after the package is globally renamed
+            if (targetConfig.executor !== '@nx/eslint:eslint') {
+                continue;
+            }
+            needsUpdate = true;
+            projectConfiguration.targets[targetName].executor = '@nx/eslint:lint';
+        }
+        if (needsUpdate) {
+            (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
+        }
+    }
+}

package/src/migrations/update-17-1-0/update-typescript-eslint.d.ts

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

package/src/migrations/update-17-1-0/update-typescript-eslint.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../utils/versions");
+const path_1 = require("path");
+const typescript_1 = require("typescript");
+function updateJestConfig(tree) {
+    const jestConfigPath = 'tools/eslint-rules/jest.config.ts';
+    if (tree.exists(jestConfigPath)) {
+        const { removePropertyFromJestConfig } = (0, devkit_1.ensurePackage)('@nx/jest', versions_1.nxVersion);
+        removePropertyFromJestConfig(tree, jestConfigPath, [
+            'moduleNameMapper',
+            '@eslint/eslintrc',
+        ]);
+    }
+}
+function updateTsConfigs(tree) {
+    const tsConfigPath = 'tools/eslint-rules/tsconfig.json';
+    if (tree.exists(tsConfigPath)) {
+        (0, devkit_1.updateJson)(tree, tsConfigPath, (tsConfig) => {
+            tsConfig.compilerOptions ??= {};
+            tsConfig.compilerOptions.moduleResolution = 'node16';
+            tsConfig.compilerOptions.module = 'node16';
+            return tsConfig;
+        });
+    }
+    const tsConfigSpec = 'tools/eslint-rules/tsconfig.spec.json';
+    if (tree.exists(tsConfigSpec)) {
+        (0, devkit_1.updateJson)(tree, tsConfigSpec, (tsConfigSpec) => {
+            delete tsConfigSpec.compilerOptions?.module;
+            delete tsConfigSpec.compilerOptions?.moduleResolution;
+            return tsConfigSpec;
+        });
+    }
+}
+function updateRecommended(tree) {
+    (0, devkit_1.visitNotIgnoredFiles)(tree, 'tools/eslint-rules', (path) => {
+        if ((0, path_1.extname)(path) !== '.ts') {
+            return;
+        }
+        const contents = tree.read(path, 'utf-8');
+        const sourceFile = (0, typescript_1.createSourceFile)(path, contents, typescript_1.ScriptTarget.ESNext, true);
+        const changes = [];
+        const visit = (node) => {
+            if ((0, typescript_1.isPropertyAssignment)(node) &&
+                (0, typescript_1.isIdentifier)(node.name) &&
+                node.name.text === 'recommended' &&
+                (0, typescript_1.isStringLiteral)(node.initializer)) {
+                changes.push({
+                    type: devkit_1.ChangeType.Delete,
+                    start: node.initializer.getStart(sourceFile),
+                    length: node.initializer.getWidth(sourceFile),
+                });
+                changes.push({
+                    type: devkit_1.ChangeType.Insert,
+                    index: node.initializer.getStart(sourceFile),
+                    text: "'recommended'",
+                });
+            }
+            else {
+                (0, typescript_1.forEachChild)(node, visit);
+            }
+        };
+        (0, typescript_1.forEachChild)(sourceFile, visit);
+        tree.write(path, (0, devkit_1.applyChangesToString)(contents, changes));
+    });
+}
+async function update(tree) {
+    updateJestConfig(tree);
+    updateTsConfigs(tree);
+    updateRecommended(tree);
+    await (0, devkit_1.formatFiles)(tree);
+}

package/src/migrations/update-17-2-0/simplify-eslint-patterns.d.ts

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

package/src/migrations/update-17-2-0/simplify-eslint-patterns.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+async function update(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    for (const [projectName, projectConfiguration] of projects) {
+        let needsUpdate = false;
+        for (const [targetName, targetConfig] of Object.entries(projectConfiguration.targets ?? {})) {
+            if (targetConfig.executor !== '@nx/eslint:lint') {
+                continue;
+            }
+            needsUpdate = true;
+            if (projectConfiguration.targets[targetName].options?.lintFilePatterns) {
+                const rootPattern = getLintRoot(projectConfiguration);
+                const nonRootPatterns = projectConfiguration.targets[targetName].options.lintFilePatterns.filter((p) => !p.startsWith(rootPattern) && !p.startsWith('{projectRoot}'));
+                if (nonRootPatterns.length === 0 &&
+                    rootPattern === projectConfiguration.root) {
+                    // delete the lintFilePatterns option if it's the only option and matches the root of the project
+                    delete projectConfiguration.targets[targetName].options
+                        .lintFilePatterns;
+                    if (Object.keys(projectConfiguration.targets[targetName].options)
+                        .length === 0) {
+                        delete projectConfiguration.targets[targetName].options;
+                    }
+                }
+                else {
+                    projectConfiguration.targets[targetName].options.lintFilePatterns = [
+                        rootPattern,
+                        ...nonRootPatterns,
+                    ];
+                }
+            }
+        }
+        if (needsUpdate) {
+            (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
+        }
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function getLintRoot({ root, sourceRoot }) {
+    if (root === '' || root === '.') {
+        return sourceRoot || './src';
+    }
+    return root;
+}

package/src/migrations/update-17-2-9/move-options-to-target-defaults.d.ts

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

package/src/migrations/update-17-2-9/move-options-to-target-defaults.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const eslint_file_1 = require("../../generators/utils/eslint-file");
+const project_configuration_utils_1 = require("nx/src/project-graph/utils/project-configuration-utils");
+async function update(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    // Don't override anything if there are already target defaults for eslint
+    if (nxJson.targetDefaults?.['@nx/eslint:lint']) {
+        return;
+    }
+    nxJson.targetDefaults ??= {};
+    const graph = await (0, devkit_1.createProjectGraphAsync)();
+    const lintTargets = new Set();
+    (0, executor_options_utils_1.forEachExecutorOptionsInGraph)(graph, '@nx/eslint:lint', (value, proj, targetName) => {
+        lintTargets.add(targetName);
+    });
+    // Workspace does not use eslint?
+    if (lintTargets.size === 0) {
+        return;
+    }
+    const lintDefaults = (nxJson.targetDefaults['@nx/eslint:lint'] = {});
+    // All eslint targets have the same name
+    if (lintTargets.size === 1) {
+        const targetName = Array.from(lintTargets)[0];
+        if (nxJson.targetDefaults[targetName]) {
+            Object.assign(lintDefaults, nxJson.targetDefaults[targetName]);
+        }
+    }
+    lintDefaults.cache ??= true;
+    if (!lintDefaults.inputs) {
+        const eslintConfig = (0, eslint_file_1.findEslintFile)(tree);
+        lintDefaults.inputs = [
+            'default',
+            ...(eslintConfig ? [`{workspaceRoot}/${eslintConfig}`] : []),
+            '{workspaceRoot}/tools/eslint-rules/**/*',
+        ];
+    }
+    // Cleanup old target defaults
+    const projects = graph.nodes;
+    const projectMap = (0, devkit_1.getProjects)(tree);
+    for (const [targetDefaultKey, targetDefault] of Object.entries(nxJson.targetDefaults)) {
+        if (!isTargetDefaultUsed(targetDefault, nxJson.targetDefaults, projects, projectMap)) {
+            delete nxJson.targetDefaults[targetDefaultKey];
+        }
+    }
+    let addOutputs = false;
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/eslint:lint', (options, proj, targetName, configuration) => {
+        const projConfig = projectMap.get(proj);
+        // modify lint file patterns
+        if (options.lintFilePatterns) {
+            const projectRootRegex = new RegExp(`^${projConfig.root}/`);
+            projConfig.targets[targetName].options.lintFilePatterns =
+                options.lintFilePatterns
+                    .filter((filePattern) => filePattern !== '{projectRoot}' &&
+                    filePattern !== projConfig.root)
+                    .map((filePattern) => filePattern.replace(projectRootRegex, '{projectRoot}/'));
+            // remove lintFilePatterns if empty
+            if (projConfig.targets[targetName].options.lintFilePatterns.length === 0) {
+                delete projConfig.targets[targetName].options.lintFilePatterns;
+            }
+        }
+        // remove inputs if they are not bringing any new inputs
+        if (projConfig.targets[targetName].inputs &&
+            projConfig.targets[targetName].inputs.every((i) => lintDefaults.inputs.includes(i))) {
+            delete projConfig.targets[targetName].inputs;
+        }
+        // remove obsolete eslint config definition, unless it's a custom one
+        const projectEslintConfig = (0, eslint_file_1.findEslintFile)(tree, projConfig.root);
+        if (options.eslintConfig === `${projConfig.root}/${projectEslintConfig}` ||
+            options.eslintConfig === `{projectRoot}/${projectEslintConfig}`) {
+            delete projConfig.targets[targetName].options.eslintConfig;
+        }
+        // remove options if empty
+        if (Object.keys(projConfig.targets[targetName]?.options ?? {}).length === 0) {
+            delete projConfig.targets[targetName].options;
+        }
+        // track output
+        if (options.outputFile) {
+            addOutputs = true;
+        }
+        if (projConfig.targets[targetName].outputs?.length === 1 &&
+            projConfig.targets[targetName].outputs[0] === '{options.outputFile}') {
+            delete projConfig.targets[targetName].outputs;
+        }
+        (0, devkit_1.updateProjectConfiguration)(tree, proj, projConfig);
+    });
+    if (addOutputs) {
+        lintDefaults.outputs = ['{options.outputFile}'];
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+    await (0, devkit_1.formatFiles)(tree);
+}
+function isTargetDefaultUsed(targetDefault, targetDefaults, projects, projectMap) {
+    for (const p of Object.values(projects)) {
+        for (const targetName in p.data?.targets ?? {}) {
+            if ((0, project_configuration_utils_1.readTargetDefaultsForTarget)(targetName, targetDefaults, 
+            // It might seem like we should use the graph here too but we don't want to pass an executor which was processed in the graph
+            projectMap.get(p.name)?.targets?.[targetName]?.executor) === targetDefault) {
+                return true;
+            }
+        }
+    }
+    return false;
+}

package/src/plugins/plugin.js

@@ -13,18 +13,7 @@ const semver_1 = require("semver");
 const config_file_1 = require("../utils/config-file");
 const resolve_eslint_class_1 = require("../utils/resolve-eslint-class");
 const pmc = (0, devkit_1.getPackageManagerCommand)();
-const DEFAULT_EXTENSIONS = [
-    'ts',
-    'cts',
-    'mts',
-    'tsx',
-    'js',
-    'cjs',
-    'mjs',
-    'jsx',
-    'html',
-    'vue',
-];
+const DEFAULT_EXTENSIONS = ['ts', 'tsx', 'js', 'jsx', 'html', 'vue'];
 const PROJECT_CONFIG_FILENAMES = ['project.json', 'package.json'];
 const ESLINT_CONFIG_GLOB_V1 = (0, globs_1.combineGlobPatterns)(config_file_1.ESLINT_CONFIG_FILENAMES.map((f) => `**/${f}`));
 const ESLINT_CONFIG_GLOB_V2 = (0, globs_1.combineGlobPatterns)([
@@ -107,7 +96,7 @@ const internalCreateNodes = async (configFilePath, options, context, projectsCac
         projects,
     };
 };
-const internalCreateNodesV2 = async (configFilePath, options, context, projectRootsByEslintRoots, lintableFilesPerProjectRoot, projectsCache, hashByRoot) => {
+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)({
         useFlatConfigOverrideVal: (0, config_file_1.isFlatConfig)(configFilePath),
@@ -115,7 +104,12 @@ const internalCreateNodesV2 = async (configFilePath, options, context, projectRo
     const eslintVersion = ESLint.version;
     const projects = {};
     await Promise.all(projectRootsByEslintRoots.get(configDir).map(async (projectRoot) => {
-        const hash = hashByRoot.get(projectRoot);
+        const parentConfigs = eslintConfigFiles.filter((eslintConfig) => isSubDir(projectRoot, (0, posix_1.dirname)(eslintConfig)));
+        const hash = await (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, {
+            configFiles: eslintConfigFiles,
+            nxJsonConfiguration: context.nxJsonConfiguration,
+            workspaceRoot: context.workspaceRoot,
+        }, [...parentConfigs, (0, posix_1.join)(projectRoot, '.eslintignore')]);
         if (projectsCache[hash]) {
             // We can reuse the projects in the cache.
             Object.assign(projects, projectsCache[hash]);
@@ -160,13 +154,8 @@ exports.createNodesV2 = [
         const targetsCache = readTargetsCache(cachePath);
         const { eslintConfigFiles, projectRoots, projectRootsByEslintRoots } = splitConfigFiles(configFiles);
         const lintableFilesPerProjectRoot = await collectLintableFilesByProjectRoot(projectRoots, options, context);
-        const hashes = await (0, calculate_hash_for_create_nodes_1.calculateHashesForCreateNodes)(projectRoots, options, context, projectRoots.map((root) => {
-            const parentConfigs = eslintConfigFiles.filter((eslintConfig) => isSubDir(root, (0, posix_1.dirname)(eslintConfig)));
-            return [...parentConfigs, (0, posix_1.join)(root, '.eslintignore')];
-        }));
-        const hashByRoot = new Map(projectRoots.map((r, i) => [r, hashes[i]]));
         try {
-            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => internalCreateNodesV2(configFile, options, context, projectRootsByEslintRoots, lintableFilesPerProjectRoot, targetsCache, hashByRoot), 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);
@@ -241,7 +230,7 @@ function getRootForDirectory(directory, roots) {
 function getProjectUsingESLintConfig(configFilePath, projectRoot, eslintVersion, options, context) {
     const rootEslintConfig = [
         config_file_1.baseEsLintConfigFile,
-        ...config_file_1.BASE_ESLINT_CONFIG_FILENAMES,
+        config_file_1.baseEsLintFlatConfigFile,
         ...config_file_1.ESLINT_CONFIG_FILENAMES,
     ].find((f) => (0, node_fs_1.existsSync)((0, posix_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

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

@@ -1,10 +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 BASE_ESLINT_CONFIG_FILENAMES: string[];
 export declare const baseEsLintConfigFile = ".eslintrc.base.json";
-export declare const baseEsLintFlatConfigFile = "eslint.base.config.mjs";
-export declare const legacyBaseEsLintFlatConfigFile = "eslint.base.config.js";
+export declare const baseEsLintFlatConfigFile = "eslint.base.config.js";
 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,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.legacyBaseEsLintFlatConfigFile = exports.baseEsLintFlatConfigFile = exports.baseEsLintConfigFile = exports.BASE_ESLINT_CONFIG_FILENAMES = exports.ESLINT_CONFIG_FILENAMES = exports.ESLINT_OLD_CONFIG_FILENAMES = exports.ESLINT_FLAT_CONFIG_FILENAMES = void 0;
+exports.baseEsLintFlatConfigFile = exports.baseEsLintConfigFile = exports.ESLINT_CONFIG_FILENAMES = exports.ESLINT_OLD_CONFIG_FILENAMES = exports.ESLINT_FLAT_CONFIG_FILENAMES = void 0;
 exports.isFlatConfig = isFlatConfig;
 exports.findFlatConfigFile = findFlatConfigFile;
 exports.findOldConfigFile = findOldConfigFile;
@@ -20,11 +20,8 @@ exports.ESLINT_CONFIG_FILENAMES = [
     ...exports.ESLINT_OLD_CONFIG_FILENAMES,
     ...exports.ESLINT_FLAT_CONFIG_FILENAMES,
 ];
-exports.BASE_ESLINT_CONFIG_FILENAMES = flat_config_1.baseEslintConfigFilenames;
 exports.baseEsLintConfigFile = '.eslintrc.base.json';
-exports.baseEsLintFlatConfigFile = 'eslint.base.config.mjs';
-// Make sure we can handle previous file extension as well for migrations or custom generators.
-exports.legacyBaseEsLintFlatConfigFile = 'eslint.base.config.js';
+exports.baseEsLintFlatConfigFile = 'eslint.base.config.js';
 function isFlatConfig(configFilePath) {
     const configFileName = (0, path_1.basename)(configFilePath);
     return exports.ESLINT_FLAT_CONFIG_FILENAMES.includes(configFileName);

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

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

package/src/utils/flat-config.js

@@ -1,19 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.baseEslintConfigFilenames = exports.eslintFlatConfigFilenames = void 0;
+exports.eslintFlatConfigFilenames = void 0;
 exports.getRootESLintFlatConfigFilename = getRootESLintFlatConfigFilename;
 exports.useFlatConfig = useFlatConfig;
 const semver_1 = require("semver");
+// todo: add support for eslint.config.mjs,
 exports.eslintFlatConfigFilenames = [
-    'eslint.config.cjs',
     'eslint.config.js',
-    'eslint.config.mjs',
-];
-exports.baseEslintConfigFilenames = [
-    'eslint.base.js',
-    'eslint.base.config.cjs',
-    'eslint.base.config.js',
-    'eslint.base.config.mjs',
+    'eslint.config.cjs',
 ];
 function getRootESLintFlatConfigFilename(tree) {
     for (const file of exports.eslintFlatConfigFilenames) {

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

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