@nx/eslint 23.0.0-beta.2 → 23.0.0-beta.21

package/{src → dist/src}/generators/init/init.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initEsLint = initEsLint;
 exports.lintInitGenerator = lintInitGenerator;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const add_plugin_1 = require("@nx/devkit/src/utils/add-plugin");
+const assert_supported_eslint_version_1 = require("../../utils/assert-supported-eslint-version");
 const versions_1 = require("../../utils/versions");
 const eslint_file_1 = require("../utils/eslint-file");
 const plugin_1 = require("../../plugins/plugin");
@@ -21,19 +22,32 @@ function updateProductionFileset(tree, format = 'mjs') {
     (0, devkit_1.updateNxJson)(tree, nxJson);
 }
 function addTargetDefaults(tree, format) {
-    const nxJson = (0, devkit_1.readNxJson)(tree);
-    nxJson.targetDefaults ??= {};
-    nxJson.targetDefaults['@nx/eslint:lint'] ??= {};
-    nxJson.targetDefaults['@nx/eslint:lint'].cache ??= true;
-    nxJson.targetDefaults['@nx/eslint:lint'].inputs ??= [
-        'default',
-        '^default',
-        `{workspaceRoot}/.eslintrc.json`,
-        `{workspaceRoot}/.eslintignore`,
-        `{workspaceRoot}/eslint.config.${format}`,
-        '{workspaceRoot}/tools/eslint-rules/**/*',
-    ];
-    (0, devkit_1.updateNxJson)(tree, nxJson);
+    const nxJson = (0, devkit_1.readNxJson)(tree) ?? {};
+    // `@nx/eslint:lint` is an executor identifier — match defaults keyed on
+    // the executor, not on a target named that string.
+    const existing = (0, internal_1.findTargetDefault)(nxJson.targetDefaults, {
+        executor: '@nx/eslint:lint',
+    });
+    const patch = {};
+    if (existing?.cache === undefined)
+        patch.cache = true;
+    if (existing?.inputs === undefined) {
+        patch.inputs = [
+            'default',
+            '^default',
+            `{workspaceRoot}/.eslintrc.json`,
+            `{workspaceRoot}/.eslintignore`,
+            `{workspaceRoot}/eslint.config.${format}`,
+            '{workspaceRoot}/tools/eslint-rules/**/*',
+        ];
+    }
+    if (Object.keys(patch).length > 0) {
+        (0, internal_1.upsertTargetDefault)(tree, nxJson, {
+            executor: '@nx/eslint:lint',
+            ...patch,
+        });
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
 }
 function updateVsCodeRecommendedExtensions(host) {
     if (!host.exists('.vscode/extensions.json')) {
@@ -49,6 +63,7 @@ function updateVsCodeRecommendedExtensions(host) {
     });
 }
 async function initEsLint(tree, options) {
+    (0, assert_supported_eslint_version_1.assertSupportedEslintVersion)(tree);
     const nxJson = (0, devkit_1.readNxJson)(tree);
     const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
         nxJson.useInferencePlugins !== false;
@@ -75,7 +90,7 @@ async function initEsLint(tree, options) {
         '_eslint-lint',
     ];
     if (rootEslintFile && options.addPlugin && !hasPlugin) {
-        await (0, add_plugin_1.addPlugin)(tree, graph, '@nx/eslint/plugin', plugin_1.createNodesV2, {
+        await (0, internal_1.addPlugin)(tree, graph, '@nx/eslint/plugin', plugin_1.createNodesV2, {
             targetName: lintTargetNames,
         }, options.updatePackageScripts);
         return () => { };
@@ -86,7 +101,7 @@ async function initEsLint(tree, options) {
     updateProductionFileset(tree, options.eslintConfigFormat);
     updateVsCodeRecommendedExtensions(tree);
     if (options.addPlugin) {
-        await (0, add_plugin_1.addPlugin)(tree, graph, '@nx/eslint/plugin', plugin_1.createNodesV2, {
+        await (0, internal_1.addPlugin)(tree, graph, '@nx/eslint/plugin', plugin_1.createNodesV2, {
             targetName: lintTargetNames,
         }, options.updatePackageScripts);
     }
@@ -95,11 +110,12 @@ async function initEsLint(tree, options) {
     }
     const tasks = [];
     if (!options.skipPackageJson) {
+        const { eslintVersion } = (0, versions_1.versions)(tree);
         tasks.push((0, devkit_1.removeDependenciesFromPackageJson)(tree, ['@nx/eslint'], []));
         tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
             '@nx/eslint': versions_1.nxVersion,
-            eslint: versions_1.eslintVersion,
-        }, undefined, options.keepExistingVersions));
+            eslint: eslintVersion,
+        }, undefined, options.keepExistingVersions ?? true));
     }
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }

package/{src → dist/src}/generators/init/schema.json

@@ -15,7 +15,7 @@
       "type": "boolean",
       "x-priority": "internal",
       "description": "Keep existing dependencies versions",
-      "default": false
+      "default": true
     },
     "updatePackageScripts": {
       "type": "boolean",

package/{src → dist/src}/generators/lint-project/lint-project.d.ts

@@ -22,4 +22,3 @@ interface LintProjectOptions {
 export declare function lintProjectGenerator(tree: Tree, options: LintProjectOptions): Promise<GeneratorCallback>;
 export declare function lintProjectGeneratorInternal(tree: Tree, options: LintProjectOptions): Promise<GeneratorCallback>;
 export {};
-//# sourceMappingURL=lint-project.d.ts.map

package/{src → dist/src}/generators/lint-project/lint-project.js

@@ -6,6 +6,7 @@ const devkit_1 = require("@nx/devkit");
 const eslint_file_1 = require("../utils/eslint-file");
 const path_1 = require("path");
 const init_1 = require("../init/init");
+const deprecation_1 = require("../../utils/deprecation");
 const init_migration_1 = require("../init/init-migration");
 const project_configuration_1 = require("nx/src/generators/utils/project-configuration");
 const flat_config_1 = require("../../utils/flat-config");
@@ -14,7 +15,7 @@ const config_file_1 = require("../../utils/config-file");
 const plugin_1 = require("../utils/plugin");
 const versions_1 = require("../../utils/versions");
 const setup_root_eslint_1 = require("./setup-root-eslint");
-const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const internal_1 = require("@nx/js/internal");
 function lintProjectGenerator(tree, options) {
     return lintProjectGeneratorInternal(tree, { addPlugin: false, ...options });
 }
@@ -63,6 +64,7 @@ async function lintProjectGeneratorInternal(tree, options) {
         }
     }
     else {
+        (0, deprecation_1.warnEslintExecutorGenerating)();
         projectConfig.targets ??= {};
         projectConfig.targets['lint'] = {
             executor: '@nx/eslint:lint',
@@ -235,7 +237,7 @@ function isJsAnalyzeSourceFilesEnabled(tree) {
         nxJson.extends !== 'nx/presets/npm.json');
 }
 function isBuildableLibraryProject(tree, projectConfig) {
-    return ((0, ts_solution_setup_1.getProjectType)(tree, projectConfig.root, projectConfig.projectType) ===
+    return ((0, internal_1.getProjectType)(tree, projectConfig.root, projectConfig.projectType) ===
         'library' &&
         projectConfig.targets?.build &&
         !!projectConfig.targets.build);

package/{src → dist/src}/generators/lint-project/setup-root-eslint.d.ts

@@ -6,4 +6,3 @@ export type SetupRootEsLintOptions = {
     eslintConfigFormat?: 'mjs' | 'cjs';
 };
 export declare function setupRootEsLint(tree: Tree, options: SetupRootEsLintOptions): GeneratorCallback;
-//# sourceMappingURL=setup-root-eslint.d.ts.map

package/{src → dist/src}/generators/lint-project/setup-root-eslint.js

@@ -29,24 +29,28 @@ function setUpLegacyRootEslintRc(tree, options) {
     else {
         tree.write('.eslintignore', 'node_modules\n');
     }
-    return !options.skipPackageJson
-        ? (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
-            '@nx/eslint-plugin': versions_1.nxVersion,
-            '@typescript-eslint/parser': versions_1.typescriptESLintVersion,
-            '@typescript-eslint/eslint-plugin': versions_1.typescriptESLintVersion,
-            'eslint-config-prettier': versions_1.eslintConfigPrettierVersion,
-        })
-        : () => { };
+    if (options.skipPackageJson) {
+        return () => { };
+    }
+    const { typescriptESLintVersion } = (0, versions_1.versions)(tree);
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+        '@nx/eslint-plugin': versions_1.nxVersion,
+        '@typescript-eslint/parser': typescriptESLintVersion,
+        '@typescript-eslint/eslint-plugin': typescriptESLintVersion,
+        'eslint-config-prettier': versions_1.eslintConfigPrettierVersion,
+    }, undefined, true);
 }
 function setUpRootFlatConfig(tree, options) {
     tree.write(`eslint.config.${options.eslintConfigFormat}`, (0, global_eslint_config_1.getGlobalFlatEslintConfiguration)(options.eslintConfigFormat, 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,
-        })
-        : () => { };
+    if (options.skipPackageJson) {
+        return () => { };
+    }
+    const { eslintVersion, typescriptESLintVersion } = (0, versions_1.versions)(tree);
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+        '@eslint/js': eslintVersion,
+        '@nx/eslint-plugin': versions_1.nxVersion,
+        eslint: eslintVersion,
+        'eslint-config-prettier': versions_1.eslintConfigPrettierVersion,
+        'typescript-eslint': typescriptESLintVersion,
+    }, undefined, true);
 }

package/{src → dist/src}/generators/utils/eslint-file.d.ts

@@ -28,4 +28,3 @@ export declare function addPredefinedConfigToFlatLintConfig(tree: Tree, root: st
 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;
-//# sourceMappingURL=eslint-file.d.ts.map

package/{src → dist/src}/generators/utils/eslint-file.js

@@ -14,10 +14,8 @@ 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");
@@ -312,9 +310,9 @@ function addExtendsToLintConfig(tree, root, plugin, insertAtTheEnd = false) {
                     ? 'cjs'
                     : 'mjs';
         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')) {
+        // assume eslint major is 9 if not found, as it's what we'd be generating by default
+        const eslintMajor = (0, versions_1.getInstalledEslintMajorVersion)(tree) ?? 9;
+        if (eslintMajor >= 9) {
             // 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 = [];

package/{src → dist/src}/generators/utils/eslint-targets.d.ts

@@ -1,3 +1,2 @@
 import { Tree } from '@nx/devkit';
 export declare function getEslintTargets(tree: Tree): Set<string>;
-//# sourceMappingURL=eslint-targets.d.ts.map

package/dist/src/generators/utils/eslint-targets.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEslintTargets = getEslintTargets;
+const internal_1 = require("@nx/devkit/internal");
+function getEslintTargets(tree) {
+    const eslintTargetNames = new Set();
+    (0, internal_1.forEachExecutorOptions)(tree, '@nx/eslint:lint', (_, __, target) => {
+        eslintTargetNames.add(target);
+    });
+    (0, internal_1.forEachExecutorOptions)(tree, '@nx/linter:eslint', (_, __, target) => {
+        eslintTargetNames.add(target);
+    });
+    (0, internal_1.forEachExecutorOptions)(tree, '@nrwl/linter:eslint', (_, __, target) => {
+        eslintTargetNames.add(target);
+    });
+    return eslintTargetNames;
+}

package/{src → dist/src}/generators/utils/flat-config/ast-utils.d.ts

@@ -73,7 +73,7 @@ export declare function overrideNeedsCompat(override: Partial<Linter.ConfigOverr
  */
 export declare function generateFlatOverride(_override: Partial<Linter.ConfigOverride<Linter.RulesRecord>> & {
     ignores?: Linter.FlatConfig['ignores'];
-}, format: 'mjs' | 'cjs'): ts.ObjectLiteralExpression | ts.SpreadElement;
+}, format: 'mjs' | 'cjs', importsMap?: Map<string, string>): ts.ObjectLiteralExpression | ts.SpreadElement;
 export declare function generateFlatPredefinedConfig(predefinedConfigName: string, moduleName?: string, spread?: boolean): ts.ObjectLiteralExpression | ts.SpreadElement | ts.ElementAccessExpression;
 export declare function mapFilePaths<T extends Partial<Linter.ConfigOverride<Linter.RulesRecord>>>(_override: T): T;
 /**
@@ -83,4 +83,3 @@ export declare function generateAst<T>(input: unknown, propertyAssignmentReplace
     keyToMatch: RegExp | string;
     replacer: (propertyAssignment: ts.PropertyAssignment, propertyName: string) => ts.PropertyAssignment;
 }): T;
-//# sourceMappingURL=ast-utils.d.ts.map

package/{src → dist/src}/generators/utils/flat-config/ast-utils.js

@@ -1101,7 +1101,7 @@ function overrideNeedsCompat(override) {
  * 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, format) {
+function generateFlatOverride(_override, format, importsMap) {
     const override = mapFilePaths(_override);
     // We do not need the compat tooling for this override
     if (!overrideNeedsCompat(override)) {
@@ -1159,7 +1159,7 @@ function generateFlatOverride(_override, format) {
                 else {
                     // Change parser to import statement.
                     return format === 'mjs'
-                        ? generateESMParserImport(override)
+                        ? generateESMParserImport(override, importsMap)
                         : generateCJSParserImport(override);
                 }
             },
@@ -1215,12 +1215,19 @@ function generateFlatOverride(_override, format) {
         ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createParenthesizedExpression(ts.factory.createObjectLiteralExpression(objectLiteralElements, true))),
     ]));
 }
-function generateESMParserImport(override) {
-    return ts.factory.createPropertyAssignment('parser', ts.factory.createAwaitExpression(ts.factory.createCallExpression(ts.factory.createIdentifier('import'), undefined, [
-        ts.factory.createStringLiteral(override['languageOptions']?.['parserOptions']?.parser ??
-            override['languageOptions']?.parser ??
-            override.parser),
-    ])));
+function generateESMParserImport(override, importsMap) {
+    const parser = override['languageOptions']?.['parserOptions']?.parser ??
+        override['languageOptions']?.parser ??
+        override.parser;
+    // Dynamic `await import()` doesn't expose top-level CJS exports (e.g. `parseForESLint`)
+    // because those are nested under `.default`. Use a hoisted static import instead so the
+    // resolved binding matches the parser's module.exports shape.
+    if (importsMap) {
+        const parserName = importsMap.get(parser) ?? (0, devkit_1.names)(parser).propertyName;
+        importsMap.set(parser, parserName);
+        return ts.factory.createPropertyAssignment('parser', ts.factory.createIdentifier(parserName));
+    }
+    return ts.factory.createPropertyAssignment('parser', ts.factory.createAwaitExpression(ts.factory.createCallExpression(ts.factory.createIdentifier('import'), undefined, [ts.factory.createStringLiteral(parser)])));
 }
 function generateCJSParserImport(override) {
     return ts.factory.createPropertyAssignment('parser', ts.factory.createCallExpression(ts.factory.createIdentifier('require'), undefined, [
@@ -1237,17 +1244,13 @@ function mapFilePaths(_override) {
     const override = {
         ..._override,
     };
+    // Dedupe after mapping — both source-side duplicates and glob-mapping collisions collapse.
+    const normalize = (value) => Array.from(new Set((Array.isArray(value) ? value : [value]).map(path_utils_1.mapFilePath)));
     if (override.files) {
-        override.files = Array.isArray(override.files)
-            ? override.files
-            : [override.files];
-        override.files = override.files.map((file) => (0, path_utils_1.mapFilePath)(file));
+        override.files = normalize(override.files);
     }
     if (override.excludedFiles) {
-        override.excludedFiles = Array.isArray(override.excludedFiles)
-            ? override.excludedFiles
-            : [override.excludedFiles];
-        override.excludedFiles = override.excludedFiles.map((file) => (0, path_utils_1.mapFilePath)(file));
+        override.excludedFiles = normalize(override.excludedFiles);
     }
     return override;
 }

package/{src → dist/src}/generators/utils/flat-config/path-utils.d.ts

@@ -1,4 +1,3 @@
 import type { Linter } from 'eslint';
 export declare function updateFiles(override: Linter.ConfigOverride<Linter.RulesRecord>): Linter.ConfigOverride<Linter.RulesRecord>;
 export declare function mapFilePath(filePath: string): string;
-//# sourceMappingURL=path-utils.d.ts.map

package/{src → dist/src}/generators/utils/linter.d.ts

@@ -6,4 +6,3 @@ export declare enum Linter {
     None = "none"
 }
 export type LinterType = 'eslint' | 'none';
-//# sourceMappingURL=linter.d.ts.map

package/{src → dist/src}/generators/utils/plugin.d.ts

@@ -1,3 +1,2 @@
 import { Tree } from '@nx/devkit';
 export declare function hasEslintPlugin(tree: Tree): boolean;
-//# sourceMappingURL=plugin.d.ts.map

package/{src → dist/src}/generators/workspace-rule/workspace-rule.d.ts

@@ -4,4 +4,3 @@ export interface LintWorkspaceRuleGeneratorOptions {
     directory: string;
 }
 export declare function lintWorkspaceRuleGenerator(tree: Tree, options: LintWorkspaceRuleGeneratorOptions): Promise<GeneratorCallback>;
-//# sourceMappingURL=workspace-rule.d.ts.map

package/{src → dist/src}/generators/workspace-rule/workspace-rule.js

@@ -2,15 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lintWorkspaceRuleGenerator = lintWorkspaceRuleGenerator;
 const tslib_1 = require("tslib");
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const string_utils_1 = require("@nx/devkit/src/utils/string-utils");
 const path_1 = require("path");
 const ts = tslib_1.__importStar(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 assert_supported_eslint_version_1 = require("../../utils/assert-supported-eslint-version");
 const flat_config_1 = require("../../utils/flat-config");
 const versions_1 = require("../../utils/versions");
 async function lintWorkspaceRuleGenerator(tree, options) {
+    (0, assert_supported_eslint_version_1.assertSupportedEslintVersion)(tree);
     const tasks = [];
     const flatConfig = (0, flat_config_1.useFlatConfig)(tree);
     const nxJson = (0, devkit_1.readNxJson)(tree);
@@ -21,7 +23,8 @@ async function lintWorkspaceRuleGenerator(tree, options) {
             nxJson.useInferencePlugins !== false,
     }));
     if (flatConfig) {
-        tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@typescript-eslint/rule-tester': versions_1.eslint9__typescriptESLintVersion }));
+        const { typescriptESLintVersion } = (0, versions_1.versions)(tree);
+        tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@typescript-eslint/rule-tester': typescriptESLintVersion }, undefined, true));
     }
     const ruleDir = (0, devkit_1.joinPathFragments)(workspace_lint_rules_1.workspaceLintPluginDir, options.directory ?? '');
     // Generate the required files for the new rule
@@ -30,7 +33,7 @@ async function lintWorkspaceRuleGenerator(tree, options) {
         name: options.name,
         flatConfig,
     });
-    const nameCamelCase = (0, string_utils_1.camelize)(options.name);
+    const nameCamelCase = (0, internal_1.camelize)(options.name);
     /**
      * Import the new rule into the workspace plugin index.ts and
      * register it ready for use in lint configs.

package/{src → dist/src}/generators/workspace-rules-project/workspace-rules-project.d.ts

@@ -6,4 +6,3 @@ export interface LintWorkspaceRulesProjectGeneratorOptions {
     addPlugin?: boolean;
 }
 export declare function lintWorkspaceRulesProjectGenerator(tree: Tree, options?: LintWorkspaceRulesProjectGeneratorOptions): Promise<GeneratorCallback>;
-//# sourceMappingURL=workspace-rules-project.d.ts.map

package/{src → dist/src}/generators/workspace-rules-project/workspace-rules-project.js

@@ -4,15 +4,15 @@ exports.WORKSPACE_PLUGIN_DIR = exports.WORKSPACE_RULES_PROJECT_NAME = void 0;
 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 internal_1 = require("@nx/js/internal");
 const path_1 = require("path");
+const assert_supported_eslint_version_1 = require("../../utils/assert-supported-eslint-version");
 const versions_1 = require("../../utils/versions");
-const version_utils_1 = require("../../utils/version-utils");
 const workspace_lint_rules_1 = require("../../utils/workspace-lint-rules");
 exports.WORKSPACE_RULES_PROJECT_NAME = 'eslint-rules';
 exports.WORKSPACE_PLUGIN_DIR = 'tools/eslint-rules';
 async function lintWorkspaceRulesProjectGenerator(tree, options = {}) {
+    (0, assert_supported_eslint_version_1.assertSupportedEslintVersion)(tree);
     const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/jest', versions_1.nxVersion);
     const tasks = [];
     // Noop if the workspace rules project already exists
@@ -38,8 +38,9 @@ async function lintWorkspaceRulesProjectGenerator(tree, options = {}) {
      * TODO: Explore writing a ProjectGraph plugin to make this more surgical.
      */
     const nxJson = (0, devkit_1.readNxJson)(tree);
-    if (nxJson.targetDefaults?.lint?.inputs) {
-        nxJson.targetDefaults.lint.inputs.push(`{workspaceRoot}/${exports.WORKSPACE_PLUGIN_DIR}/**/*`);
+    const lintEntry = findLintTargetDefault(nxJson.targetDefaults);
+    if (lintEntry?.inputs) {
+        lintEntry.inputs.push(`{workspaceRoot}/${exports.WORKSPACE_PLUGIN_DIR}/**/*`);
         (0, devkit_1.updateNxJson)(tree, nxJson);
     }
     // Add jest to the project and return installation task
@@ -49,7 +50,7 @@ async function lintWorkspaceRulesProjectGenerator(tree, options = {}) {
         supportTsx: false,
         skipSerializers: true,
         setupFile: 'none',
-        compiler: (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree) ? 'swc' : 'tsc',
+        compiler: (0, internal_1.isUsingTsSolutionSetup)(tree) ? 'swc' : 'tsc',
         skipFormat: true,
         testEnvironment: 'node',
     }));
@@ -75,13 +76,23 @@ async function lintWorkspaceRulesProjectGenerator(tree, options = {}) {
         return json;
     });
     // Add swc dependencies
-    tasks.push((0, add_swc_dependencies_1.addSwcRegisterDependencies)(tree));
-    const typescriptEslintVersion = (0, version_utils_1.getTypeScriptEslintVersionToInstall)(tree);
+    tasks.push((0, internal_1.addSwcRegisterDependencies)(tree));
+    const { typescriptESLintVersion } = (0, versions_1.versions)(tree);
     tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
-        '@typescript-eslint/utils': typescriptEslintVersion,
-    }));
+        '@typescript-eslint/utils': typescriptESLintVersion,
+    }, undefined, true));
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
+function findLintTargetDefault(td) {
+    if (!td)
+        return undefined;
+    if (Array.isArray(td)) {
+        return td.find((e) => e.target === 'lint' &&
+            e.projects === undefined &&
+            e.plugin === undefined);
+    }
+    return td['lint'];
+}

package/{src → dist/src}/migrations/update-20-2-0/update-typescript-eslint-v8-13-0.d.ts

@@ -1,3 +1,2 @@
 import { type GeneratorCallback, type Tree } from '@nx/devkit';
 export default function (tree: Tree): Promise<GeneratorCallback>;
-//# sourceMappingURL=update-typescript-eslint-v8-13-0.d.ts.map

package/{src → dist/src}/migrations/update-20-2-0/update-typescript-eslint-v8-13-0.js

@@ -2,12 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = default_1;
 const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
 const semver_1 = require("semver");
-const version_utils_1 = require("../../utils/version-utils");
 async function default_1(tree) {
     const devDependencies = {};
+    // `@typescript-eslint/parser >=8.0.0` is enforced at the `requires` gate
+    // in `migrations.json`. The per-package `gte('8.0.0') && lt('8.13.0')`
+    // check below catches the lockstep-broken case where one of the four
+    // typescript-eslint packages is at a different major than the parser.
     const checkPackageAndMigrate = (pkgName) => {
-        const pkgVersion = (0, version_utils_1.getInstalledPackageVersion)(pkgName, tree);
+        const pkgVersion = (0, internal_1.getDeclaredPackageVersion)(tree, pkgName);
         if (!!pkgVersion && (0, semver_1.gte)(pkgVersion, '8.0.0') && (0, semver_1.lt)(pkgVersion, '8.13.0')) {
             devDependencies[pkgName] = '^8.13.0';
         }

package/dist/src/migrations/update-20-2-0/update-typescript-eslint-v8-13-0.md

@@ -0,0 +1,33 @@
+#### Update TypeScript ESLint to v8.13.0
+
+Update TypeScript ESLint packages to v8.13.0 if they are already on v8
+
+#### Sample Code Changes
+
+This migration will update `typescript-eslint`, `@typescript-eslint/eslint-plugin`, `@typescript-eslint/parser` and `@typescript-eslint/utils` to `8.13.0` if they are between version `8.0.0` and `8.13.0`.
+
+##### Before
+
+```json title="package.json"
+{
+  "devDependencies": {
+    "typescript-eslint": "^8.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "@typescript-eslint/utils": "^8.0.0"
+  }
+}
+```
+
+##### After
+
+```json title="package.json"
+{
+  "devDependencies": {
+    "typescript-eslint": "^8.13.0",
+    "@typescript-eslint/eslint-plugin": "^8.13.0",
+    "@typescript-eslint/parser": "^8.13.0",
+    "@typescript-eslint/utils": "^8.13.0"
+  }
+}
+```

package/{src → dist/src}/migrations/update-20-3-0/add-file-extensions-to-overrides.d.ts

@@ -1,3 +1,2 @@
 import { type Tree } from '@nx/devkit';
 export default function (tree: Tree): Promise<void>;
-//# sourceMappingURL=add-file-extensions-to-overrides.d.ts.map

package/dist/src/migrations/update-20-3-0/add-file-extensions-to-overrides.md

@@ -0,0 +1,83 @@
+#### Update ESLint Config File Extensions in Overrides
+
+Update ESLint flat config to include .cjs, .mjs, .cts, and .mts files in overrides (if needed)
+
+#### Sample Code Changes
+
+Add `.cjs`, `.mjs`, `.cts`, `.mts` file extensions to overrides converted using `convert-to-flat-config`
+
+##### Before
+
+```js title="eslint.config.js"
+const { FlatCompat } = require('@eslint/eslintrc');
+const js = require('@eslint/js');
+const nxEslintPlugin = require('@nx/eslint-plugin');
+
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+});
+
+module.exports = [
+  ...compat
+    .config({
+      extends: ['plugin:@nx/typescript'],
+    })
+    .map((config) => ({
+      ...config,
+      files: ['**/*.ts', '**/*.tsx'],
+      rules: {
+        ...config.rules,
+      },
+    })),
+  ...compat
+    .config({
+      extends: ['plugin:@nx/javascript'],
+    })
+    .map((config) => ({
+      ...config,
+      files: ['**/*.js', '**/*.jsx'],
+      rules: {
+        ...config.rules,
+      },
+    })),
+];
+```
+
+##### After
+
+```js title="eslint.config.js" {17,28}
+const { FlatCompat } = require('@eslint/eslintrc');
+const js = require('@eslint/js');
+const nxEslintPlugin = require('@nx/eslint-plugin');
+
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+});
+
+module.exports = [
+  ...compat
+    .config({
+      extends: ['plugin:@nx/typescript'],
+    })
+    .map((config) => ({
+      ...config,
+      files: ['**/*.ts', '**/*.tsx', '**/*.cts', '**/*.mts'],
+      rules: {
+        ...config.rules,
+      },
+    })),
+  ...compat
+    .config({
+      extends: ['plugin:@nx/javascript'],
+    })
+    .map((config) => ({
+      ...config,
+      files: ['**/*.js', '**/*.jsx', '**/*.cjs', '**/*.mjs'],
+      rules: {
+        ...config.rules,
+      },
+    })),
+];
+```

package/{src → dist/src}/migrations/update-21-6-0/update-executor-lint-inputs.d.ts

@@ -1,3 +1,2 @@
 import { type Tree } from '@nx/devkit';
 export default function (tree: Tree): Promise<void>;
-//# sourceMappingURL=update-executor-lint-inputs.d.ts.map