@nx/eslint 23.0.0-pr.35465.2bc2643 → 23.0.0-rc.0

package/{index.d.ts → dist/index.d.ts}

@@ -1,4 +1,3 @@
 export { lintProjectGenerator } from './src/generators/lint-project/lint-project';
 export { lintInitGenerator } from './src/generators/init/init';
 export { Linter, LinterType } from './src/generators/utils/linter';
-//# sourceMappingURL=index.d.ts.map

package/dist/internal.d.ts

@@ -0,0 +1,7 @@
+export { addExtendsToLintConfig, addIgnoresToLintConfig, addOverrideToLintConfig, addPluginsToLintConfig, addPredefinedConfigToFlatLintConfig, findEslintFile, isEslintConfigSupported, lintConfigHasOverride, replaceOverridesInLintConfig, updateOverrideInLintConfig, updateRelativePathsInConfig, } from './src/generators/utils/eslint-file';
+export { addImportToFlatConfig } from './src/generators/utils/flat-config/ast-utils';
+export { useFlatConfig } from './src/utils/flat-config';
+export { javaScriptOverride, typeScriptOverride, } from './src/generators/init/global-eslint-config';
+export { setupRootEsLint } from './src/generators/lint-project/setup-root-eslint';
+export { getInstalledEslintVersion, typescriptESLintVersion, versions, } from './src/utils/versions';
+export type { Schema } from './src/executors/lint/schema';

package/dist/internal.js

@@ -0,0 +1,33 @@
+"use strict";
+// Semi-private surface for first-party Nx packages.
+//
+// External plugins should NOT import from here — this entry is curated for
+// internal consumers and may change without semver protection. Mirrors
+// `@nx/devkit/internal`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versions = exports.typescriptESLintVersion = exports.getInstalledEslintVersion = exports.setupRootEsLint = exports.typeScriptOverride = exports.javaScriptOverride = exports.useFlatConfig = exports.addImportToFlatConfig = exports.updateRelativePathsInConfig = exports.updateOverrideInLintConfig = exports.replaceOverridesInLintConfig = exports.lintConfigHasOverride = exports.isEslintConfigSupported = exports.findEslintFile = exports.addPredefinedConfigToFlatLintConfig = exports.addPluginsToLintConfig = exports.addOverrideToLintConfig = exports.addIgnoresToLintConfig = exports.addExtendsToLintConfig = void 0;
+var eslint_file_1 = require("./src/generators/utils/eslint-file");
+Object.defineProperty(exports, "addExtendsToLintConfig", { enumerable: true, get: function () { return eslint_file_1.addExtendsToLintConfig; } });
+Object.defineProperty(exports, "addIgnoresToLintConfig", { enumerable: true, get: function () { return eslint_file_1.addIgnoresToLintConfig; } });
+Object.defineProperty(exports, "addOverrideToLintConfig", { enumerable: true, get: function () { return eslint_file_1.addOverrideToLintConfig; } });
+Object.defineProperty(exports, "addPluginsToLintConfig", { enumerable: true, get: function () { return eslint_file_1.addPluginsToLintConfig; } });
+Object.defineProperty(exports, "addPredefinedConfigToFlatLintConfig", { enumerable: true, get: function () { return eslint_file_1.addPredefinedConfigToFlatLintConfig; } });
+Object.defineProperty(exports, "findEslintFile", { enumerable: true, get: function () { return eslint_file_1.findEslintFile; } });
+Object.defineProperty(exports, "isEslintConfigSupported", { enumerable: true, get: function () { return eslint_file_1.isEslintConfigSupported; } });
+Object.defineProperty(exports, "lintConfigHasOverride", { enumerable: true, get: function () { return eslint_file_1.lintConfigHasOverride; } });
+Object.defineProperty(exports, "replaceOverridesInLintConfig", { enumerable: true, get: function () { return eslint_file_1.replaceOverridesInLintConfig; } });
+Object.defineProperty(exports, "updateOverrideInLintConfig", { enumerable: true, get: function () { return eslint_file_1.updateOverrideInLintConfig; } });
+Object.defineProperty(exports, "updateRelativePathsInConfig", { enumerable: true, get: function () { return eslint_file_1.updateRelativePathsInConfig; } });
+var ast_utils_1 = require("./src/generators/utils/flat-config/ast-utils");
+Object.defineProperty(exports, "addImportToFlatConfig", { enumerable: true, get: function () { return ast_utils_1.addImportToFlatConfig; } });
+var flat_config_1 = require("./src/utils/flat-config");
+Object.defineProperty(exports, "useFlatConfig", { enumerable: true, get: function () { return flat_config_1.useFlatConfig; } });
+var global_eslint_config_1 = require("./src/generators/init/global-eslint-config");
+Object.defineProperty(exports, "javaScriptOverride", { enumerable: true, get: function () { return global_eslint_config_1.javaScriptOverride; } });
+Object.defineProperty(exports, "typeScriptOverride", { enumerable: true, get: function () { return global_eslint_config_1.typeScriptOverride; } });
+var setup_root_eslint_1 = require("./src/generators/lint-project/setup-root-eslint");
+Object.defineProperty(exports, "setupRootEsLint", { enumerable: true, get: function () { return setup_root_eslint_1.setupRootEsLint; } });
+var versions_1 = require("./src/utils/versions");
+Object.defineProperty(exports, "getInstalledEslintVersion", { enumerable: true, get: function () { return versions_1.getInstalledEslintVersion; } });
+Object.defineProperty(exports, "typescriptESLintVersion", { enumerable: true, get: function () { return versions_1.typescriptESLintVersion; } });
+Object.defineProperty(exports, "versions", { enumerable: true, get: function () { return versions_1.versions; } });

package/{plugin.d.ts → dist/plugin.d.ts}

@@ -1,2 +1 @@
 export { createNodes, createNodesV2, EslintPluginOptions, } from './src/plugins/plugin';
-//# sourceMappingURL=plugin.d.ts.map

package/{src → dist/src}/executors/lint/lint.impl.d.ts

@@ -3,4 +3,3 @@ import type { Schema } from './schema';
 export default function run(options: Schema, context: ExecutorContext): Promise<{
     success: boolean;
 }>;
-//# sourceMappingURL=lint.impl.d.ts.map

package/{src → dist/src}/executors/lint/lint.impl.js

@@ -2,12 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = run;
 const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
 const fs_1 = require("fs");
 const utils_1 = require("nx/src/tasks-runner/utils");
 const path_1 = require("path");
+const semver_1 = require("semver");
 const config_file_1 = require("../../utils/config-file");
+const deprecation_1 = require("../../utils/deprecation");
+const versions_1 = require("../../utils/versions");
 const eslint_utils_1 = require("./utility/eslint-utils");
 async function run(options, context) {
+    (0, deprecation_1.warnEslintExecutorDeprecation)();
     // hasTypeAwareRules is deprecated and no longer used, delete it so it's not passed to ESLint
     delete options.hasTypeAwareRules;
     const systemRoot = context.root;
@@ -42,12 +47,10 @@ async function run(options, context) {
         ? (0, path_1.resolve)(systemRoot, normalizedOptions.eslintConfig)
         : undefined;
     const { eslint, ESLint } = await (0, eslint_utils_1.resolveAndInstantiateESLint)(eslintConfigPath, normalizedOptions, hasFlatConfig);
-    const version = ESLint.version?.split('.');
-    if (!version ||
-        version.length < 2 ||
-        Number(version[0]) < 7 ||
-        (Number(version[0]) === 7 && Number(version[1]) < 6)) {
-        throw new Error('ESLint must be version 7.6 or higher.');
+    (0, internal_1.assertSupportedInstalledPackageVersion)('eslint', versions_1.minSupportedEslintVersion);
+    const installedEslintVersion = (0, internal_1.getInstalledPackageVersion)('eslint');
+    if (installedEslintVersion && (0, semver_1.major)(installedEslintVersion) === 8) {
+        (0, deprecation_1.warnEslintV8Deprecation)();
     }
     if (printConfig) {
         try {

package/{src → dist/src}/executors/lint/schema.json

@@ -6,6 +6,7 @@
   "description": "ESLint Lint Target.",
   "cli": "nx",
   "type": "object",
+  "x-deprecated": "The `@nx/eslint:lint` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/eslint:convert-to-inferred` to migrate to the `@nx/eslint/plugin` inferred plugin. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.",
   "properties": {
     "eslintConfig": {
       "type": "string",

package/{src → dist/src}/executors/lint/utility/eslint-utils.d.ts

@@ -4,4 +4,3 @@ export declare function resolveAndInstantiateESLint(eslintConfigPath: string | u
     ESLint: typeof import("eslint").ESLint;
     eslint: ESLint;
 }>;
-//# sourceMappingURL=eslint-utils.d.ts.map

package/{src → dist/src}/generators/convert-to-flat-config/converters/json-converter.d.ts

@@ -1,5 +1,6 @@
 import { Tree } from '@nx/devkit';
 import { ESLint } from 'eslint';
+export declare function renameLegacyEslintrcFile(path: string, format: 'mjs' | 'cjs'): string;
 /**
  * Converts an ESLint JSON config to a flat config.
  * Deletes the original file along with .eslintignore if it exists.
@@ -9,4 +10,3 @@ export declare function convertEslintJsonToFlatConfig(tree: Tree, root: string,
     addESLintRC: boolean;
     addESLintJS: boolean;
 };
-//# sourceMappingURL=json-converter.d.ts.map

package/{src → dist/src}/generators/convert-to-flat-config/converters/json-converter.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.renameLegacyEslintrcFile = renameLegacyEslintrcFile;
 exports.convertEslintJsonToFlatConfig = convertEslintJsonToFlatConfig;
 const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
@@ -7,6 +8,57 @@ const ts = tslib_1.__importStar(require("typescript"));
 const ast_utils_1 = require("../../utils/flat-config/ast-utils");
 const eslint_file_1 = require("../../utils/eslint-file");
 const path_utils_1 = require("../../utils/flat-config/path-utils");
+// Rewrites legacy `.eslintrc[.base][.json]` / `.eslintignore` filenames to their flat-config
+// counterparts. Used for `extends` local paths, rule option values that embed these filenames,
+// and nx.json / project.json input globs that referenced the deleted files. Accepts
+// extensionless `.eslintrc` since ESLint treats that as JSON by convention.
+function renameLegacyEslintrcFile(path, format) {
+    return path
+        .replace(/(^|.*?)\.eslintrc(\.base)?(\.json)?$/, `$1eslint$2.config.${format}`)
+        .replace(/(^|.*?)\.eslintignore$/, `$1eslint.config.${format}`);
+}
+// In flat config, `@nx/workspace/<rule>` is parsed as plugin `@nx/workspace`, rule `<rule>`.
+// The `@nx` plugin already exposes workspace rules under both `workspace/<rule>` and `workspace-<rule>` keys.
+// Rewriting to `@nx/workspace-<rule>` makes ESLint resolve them via the already-registered `@nx` plugin.
+function renameLegacyWorkspaceRules(rules) {
+    const renamed = {};
+    for (const [key, value] of Object.entries(rules)) {
+        const newKey = key.startsWith('@nx/workspace/')
+            ? '@nx/workspace-' + key.slice('@nx/workspace/'.length)
+            : key;
+        renamed[newKey] = value;
+    }
+    return renamed;
+}
+// Rewrites references to the legacy `.eslintrc[.base].json` / `.eslintignore` that may appear
+// inside rule option values (e.g. `@nx/dependency-checks`'s `ignoredFiles`) to point at the
+// generated flat-config files instead. Without this, rule options keep pointing at files that
+// no longer exist after the conversion.
+function rewriteStaleEslintrcRefs(value, format) {
+    if (typeof value === 'string') {
+        return renameLegacyEslintrcFile(value, format);
+    }
+    if (Array.isArray(value)) {
+        const mapped = value.map((v) => rewriteStaleEslintrcRefs(v, format));
+        // Rewriting may collapse distinct strings (e.g. `.eslintrc.json` and
+        // `.eslintrc.base.json`) into identical entries; dedupe string arrays.
+        if (mapped.every((v) => typeof v === 'string')) {
+            return Array.from(new Set(mapped));
+        }
+        return mapped;
+    }
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = rewriteStaleEslintrcRefs(v, format);
+        }
+        return out;
+    }
+    return value;
+}
+function preprocessRules(rules, format) {
+    return rewriteStaleEslintrcRefs(renameLegacyWorkspaceRules(rules), format);
+}
 /**
  * Converts an ESLint JSON config to a flat config.
  * Deletes the original file along with .eslintignore if it exists.
@@ -18,10 +70,17 @@ function convertEslintJsonToFlatConfig(tree, root, config, ignorePaths, format)
     let isESLintJSNeeded = false;
     let combinedConfig = [];
     let languageOptions = [];
-    // exclude dist and eslint config from being linted, which matches the default for new workspaces
-    exportElements.push((0, ast_utils_1.generateAst)({
-        ignores: ['**/dist', '**/out-tsc'],
-    }));
+    if (config.rules) {
+        config.rules = preprocessRules(config.rules, format);
+    }
+    if (config.overrides) {
+        config.overrides = config.overrides.map((override) => override.rules
+            ? {
+                ...override,
+                rules: preprocessRules(override.rules, format),
+            }
+            : override);
+    }
     if (config.extends) {
         const extendsResult = addExtends(importsMap, exportElements, config, format);
         isFlatCompatNeeded = extendsResult.isFlatCompatNeeded;
@@ -101,28 +160,30 @@ function convertEslintJsonToFlatConfig(tree, root, config, ignorePaths, format)
                     if (Object.keys(remainingRest).length > 0 || hasNonEmptyRules) {
                         if (remainingOverride.env ||
                             remainingOverride.extends ||
-                            remainingOverride.plugins ||
-                            remainingOverride.parser) {
+                            remainingOverride.plugins) {
                             isFlatCompatNeeded = true;
                         }
-                        exportElements.push((0, ast_utils_1.generateFlatOverride)(remainingOverride, format));
+                        exportElements.push((0, ast_utils_1.generateFlatOverride)(remainingOverride, format, importsMap));
                     }
                     return;
                 }
             }
-            if (override.env ||
-                override.extends ||
-                override.plugins ||
-                override.parser) {
+            if (override.env || override.extends || override.plugins) {
                 isFlatCompatNeeded = true;
             }
-            exportElements.push((0, ast_utils_1.generateFlatOverride)(override, format));
+            exportElements.push((0, ast_utils_1.generateFlatOverride)(override, format, importsMap));
         });
     }
     if (config.ignorePatterns) {
         const patterns = (Array.isArray(config.ignorePatterns)
             ? config.ignorePatterns
-            : [config.ignorePatterns]).filter((pattern) => !['**/*', '!**/*', 'node_modules'].includes(pattern)); // these are useless in a flat config
+            : [config.ignorePatterns]).filter((pattern) => 
+        // Drop patterns that are meaningless in flat config. `'**/*'` and
+        // `'!**/*'` were eslintrc cascading toggles; `node_modules` is already
+        // ignored by default. Real negations like `['dist/**', '!dist/keep.js']`
+        // are preserved — flat config still supports un-ignoring within a
+        // broader ignores block.
+        !['**/*', '!**/*', 'node_modules'].includes(pattern));
         if (patterns.length > 0) {
             exportElements.push((0, ast_utils_1.generateAst)({
                 ignores: patterns.map((path) => (0, path_utils_1.mapFilePath)(path)),
@@ -165,11 +226,10 @@ function addExtends(importsMap, configBlocks, config, format) {
     extendsConfig
         .filter((imp) => imp.match(/^\.?(\.\/)/))
         .forEach((imp, index) => {
-        if (imp.match(/\.eslintrc(.base)?\.json$/)) {
+        if (imp.match(/\.eslintrc(\.base)?(\.json)?$/)) {
             const localName = index ? `baseConfig${index}` : 'baseConfig';
             configBlocks.push((0, ast_utils_1.generateSpreadElement)(localName));
-            const newImport = imp.replace(/^(.*)\.eslintrc(.base)?\.json$/, `$1eslint$2.config.${format}`);
-            importsMap.set(newImport, localName);
+            importsMap.set(renameLegacyEslintrcFile(imp, format), localName);
         }
         else {
             eslintrcConfigs.push(imp);

package/{src → dist/src}/generators/convert-to-flat-config/generator.d.ts

@@ -2,4 +2,3 @@ import { GeneratorCallback, Tree } from '@nx/devkit';
 import { ConvertToFlatConfigGeneratorSchema } from './schema';
 export declare function convertToFlatConfigGenerator(tree: Tree, options: ConvertToFlatConfigGeneratorSchema): Promise<void | GeneratorCallback>;
 export default convertToFlatConfigGenerator;
-//# sourceMappingURL=generator.d.ts.map

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

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToFlatConfigGenerator = convertToFlatConfigGenerator;
+const devkit_1 = require("@nx/devkit");
+const eslint_file_1 = require("../utils/eslint-file");
+const plugin_1 = require("../utils/plugin");
+const path_1 = require("path");
+const assert_supported_eslint_version_1 = require("../../utils/assert-supported-eslint-version");
+const versions_1 = require("../../utils/versions");
+const json_converter_1 = require("./converters/json-converter");
+async function convertToFlatConfigGenerator(tree, options) {
+    (0, assert_supported_eslint_version_1.assertSupportedEslintVersion)(tree);
+    const eslintFile = (0, eslint_file_1.findEslintFile)(tree);
+    if (!eslintFile) {
+        throw new Error('Could not find root eslint file');
+    }
+    if (eslintFile.endsWith('.js')) {
+        throw new Error('Only json and yaml eslint config files are supported for conversion');
+    }
+    options.eslintConfigFormat ??= 'mjs';
+    const eslintIgnoreFiles = new Set(['.eslintignore']);
+    // convert root eslint config to eslint.config.cjs or eslint.base.config.mjs based on eslintConfigFormat
+    convertRootToFlatConfig(tree, eslintFile, options.eslintConfigFormat);
+    // convert project eslint files to eslint.config.cjs
+    const projects = (0, devkit_1.getProjects)(tree);
+    for (const [project, projectConfig] of projects) {
+        convertProjectToFlatConfig(tree, project, projectConfig, (0, devkit_1.readNxJson)(tree), eslintIgnoreFiles, options.eslintConfigFormat);
+    }
+    // delete all .eslintignore files
+    for (const ignoreFile of eslintIgnoreFiles) {
+        tree.delete(ignoreFile);
+    }
+    // replace references in nx.json and project.json files
+    updateNxJsonConfig(tree, options.eslintConfigFormat);
+    updateProjectConfigsInputs(tree, options.eslintConfigFormat);
+    // install missing packages
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return () => (0, devkit_1.installPackagesTask)(tree);
+}
+exports.default = convertToFlatConfigGenerator;
+function convertRootToFlatConfig(tree, eslintFile, format) {
+    if (/\.base\.(js|json|yml|yaml)$/.test(eslintFile)) {
+        convertConfigToFlatConfig(tree, '', eslintFile, `eslint.base.config.${format}`, format);
+    }
+    convertConfigToFlatConfig(tree, '', eslintFile.replace('.base.', '.'), `eslint.config.${format}`, format);
+}
+const ESLINT_LINT_EXECUTOR = '@nx/eslint:lint';
+function isEslintTarget(target) {
+    return (target.executor === ESLINT_LINT_EXECUTOR ||
+        target.command?.includes('eslint'));
+}
+function hasMatchingEslintTargetDefault(projectConfig, targetDefaults) {
+    if (!projectConfig.targets || !targetDefaults) {
+        return false;
+    }
+    if (Array.isArray(targetDefaults)) {
+        return targetDefaults.some((entry) => entry.target !== undefined &&
+            projectConfig.targets[entry.target] !== undefined &&
+            (entry.target === ESLINT_LINT_EXECUTOR || isEslintTarget(entry)));
+    }
+    return Object.entries(targetDefaults).some(([targetName, targetConfig]) => projectConfig.targets[targetName] !== undefined &&
+        (targetName === ESLINT_LINT_EXECUTOR || isEslintTarget(targetConfig)));
+}
+function convertProjectToFlatConfig(tree, project, projectConfig, nxJson, eslintIgnoreFiles, format) {
+    const eslintFile = (0, eslint_file_1.findEslintFile)(tree, projectConfig.root);
+    if (!eslintFile || eslintFile.endsWith('.js')) {
+        return;
+    }
+    // Clean up obsolete target options and detect explicit ESLint targets
+    let ignorePath;
+    const eslintTargets = projectConfig.targets
+        ? Object.keys(projectConfig.targets).filter((t) => isEslintTarget(projectConfig.targets[t]))
+        : [];
+    for (const target of eslintTargets) {
+        if (projectConfig.targets[target].options?.eslintConfig) {
+            delete projectConfig.targets[target].options.eslintConfig;
+        }
+        if (projectConfig.targets[target].options?.ignorePath) {
+            ignorePath = projectConfig.targets[target].options.ignorePath;
+            delete projectConfig.targets[target].options.ignorePath;
+        }
+    }
+    if (eslintTargets.length > 0) {
+        (0, devkit_1.updateProjectConfiguration)(tree, project, projectConfig);
+    }
+    const hasEslintTargetDefaults = hasMatchingEslintTargetDefault(projectConfig, nxJson.targetDefaults);
+    if (eslintTargets.length === 0 &&
+        !hasEslintTargetDefaults &&
+        !(0, plugin_1.hasEslintPlugin)(tree)) {
+        devkit_1.logger.warn(`Skipping "${project}": found ${eslintFile} but no ESLint lint target detected. Convert manually if needed.`);
+        return;
+    }
+    convertConfigToFlatConfig(tree, projectConfig.root, eslintFile, `eslint.config.${format}`, format, ignorePath);
+    eslintIgnoreFiles.add(`${projectConfig.root}/.eslintignore`);
+    if (ignorePath) {
+        eslintIgnoreFiles.add(ignorePath);
+    }
+}
+// Rewrites input entries that reference legacy `.eslintrc[.base].json` / `.eslintignore`
+// files to their flat-config counterparts, then dedupes so the rewrite doesn't produce
+// duplicates of entries that already pointed at the flat config. Leaves non-string /
+// non-fileset inputs (runtime/env/dependentTasksOutputFiles/etc.) untouched.
+function rewriteLegacyInputs(inputs, format) {
+    const seenStrings = new Set();
+    const result = [];
+    for (const entry of inputs) {
+        if (typeof entry === 'string') {
+            const rewritten = (0, json_converter_1.renameLegacyEslintrcFile)(entry, format);
+            if (seenStrings.has(rewritten))
+                continue;
+            seenStrings.add(rewritten);
+            result.push(rewritten);
+        }
+        else if ('fileset' in entry) {
+            const rewritten = (0, json_converter_1.renameLegacyEslintrcFile)(entry.fileset, format);
+            // Preserve the original reference when nothing changed so downstream identity
+            // checks (e.g. `inputsEqual`) don't see a spurious mutation.
+            result.push(rewritten === entry.fileset ? entry : { ...entry, fileset: rewritten });
+        }
+        else {
+            result.push(entry);
+        }
+    }
+    return result;
+}
+// Adds `value` to `inputs` (after rewriting) when the rewritten set doesn't already contain it.
+function ensureInputPresent(inputs, value, format) {
+    const rewritten = rewriteLegacyInputs(inputs, format);
+    if (!rewritten.some((entry) => entry === value)) {
+        rewritten.push(value);
+    }
+    return rewritten;
+}
+// Updates nx.json: rewrites stale eslintrc/eslintignore references across all targetDefaults
+// inputs and namedInputs, and ensures lint targets include the new flat config file as an input
+// (and `production` excludes it). Handles both the legacy record shape and the new array shape
+// of `targetDefaults`.
+function updateNxJsonConfig(tree, format) {
+    if (!tree.exists('nx.json')) {
+        return;
+    }
+    (0, devkit_1.updateJson)(tree, 'nx.json', (json) => {
+        const rewriteTargetInputs = (target, isLintTarget) => {
+            if (!target.inputs)
+                return;
+            target.inputs = isLintTarget
+                ? ensureInputPresent(target.inputs, `{workspaceRoot}/eslint.config.${format}`, format)
+                : rewriteLegacyInputs(target.inputs, format);
+        };
+        if (json.targetDefaults) {
+            if (Array.isArray(json.targetDefaults)) {
+                for (const entry of json.targetDefaults) {
+                    const isLintTarget = entry.target === 'lint' || entry.target === ESLINT_LINT_EXECUTOR;
+                    rewriteTargetInputs(entry, isLintTarget);
+                }
+            }
+            else {
+                for (const [name, target] of Object.entries(json.targetDefaults)) {
+                    const isLintTarget = name === 'lint' || name === ESLINT_LINT_EXECUTOR;
+                    rewriteTargetInputs(target, isLintTarget);
+                }
+            }
+        }
+        if (json.namedInputs) {
+            for (const [name, inputs] of Object.entries(json.namedInputs)) {
+                json.namedInputs[name] =
+                    name === 'production'
+                        ? ensureInputPresent(inputs, `!{projectRoot}/eslint.config.${format}`, format)
+                        : rewriteLegacyInputs(inputs, format);
+            }
+        }
+        return json;
+    });
+}
+// Walks every project's `targets.*.inputs` and `namedInputs.*`, rewriting stale references.
+function updateProjectConfigsInputs(tree, format) {
+    for (const [project, projectConfig] of (0, devkit_1.getProjects)(tree)) {
+        let changed = false;
+        if (projectConfig.targets) {
+            for (const target of Object.values(projectConfig.targets)) {
+                if (!target.inputs)
+                    continue;
+                const rewritten = rewriteLegacyInputs(target.inputs, format);
+                if (!inputsEqual(target.inputs, rewritten)) {
+                    target.inputs = rewritten;
+                    changed = true;
+                }
+            }
+        }
+        if (projectConfig.namedInputs) {
+            for (const [name, inputs] of Object.entries(projectConfig.namedInputs)) {
+                const rewritten = rewriteLegacyInputs(inputs, format);
+                if (!inputsEqual(inputs, rewritten)) {
+                    projectConfig.namedInputs[name] = rewritten;
+                    changed = true;
+                }
+            }
+        }
+        if (changed) {
+            (0, devkit_1.updateProjectConfiguration)(tree, project, projectConfig);
+        }
+    }
+}
+function inputsEqual(a, b) {
+    return a.length === b.length && a.every((entry, i) => entry === b[i]);
+}
+function convertConfigToFlatConfig(tree, root, source, target, format, ignorePath) {
+    const ignorePaths = ignorePath
+        ? [ignorePath, `${root}/.eslintignore`]
+        : [`${root}/.eslintignore`];
+    // `.eslintrc` (no extension) is JSON by convention.
+    if (source.endsWith('.json') || (0, path_1.basename)(source) === '.eslintrc') {
+        const config = (0, devkit_1.readJson)(tree, `${root}/${source}`);
+        const conversionResult = (0, json_converter_1.convertEslintJsonToFlatConfig)(tree, root, config, ignorePaths, format);
+        return processConvertedConfig(tree, root, source, target, conversionResult);
+    }
+    if (source.endsWith('.yaml') || source.endsWith('.yml')) {
+        const originalContent = tree.read(`${root}/${source}`, 'utf-8');
+        const { load } = require('@zkochan/js-yaml');
+        const config = load(originalContent, {
+            json: true,
+            filename: source,
+        });
+        const conversionResult = (0, json_converter_1.convertEslintJsonToFlatConfig)(tree, root, config, ignorePaths, format);
+        return processConvertedConfig(tree, root, source, target, conversionResult);
+    }
+}
+function processConvertedConfig(tree, root, source, target, { content, addESLintRC, addESLintJS, }) {
+    // remove original config file
+    tree.delete((0, path_1.join)(root, source));
+    // save new
+    tree.write((0, path_1.join)(root, target), content);
+    // Once converted to flat config, the workspace is on the v9 ESLint stack —
+    // install the latest typescript-eslint v8 lane explicitly rather than
+    // routing through `versions(tree)` which would pick the legacy lane based
+    // on the pre-conversion `eslintrc` workspace state.
+    const devDependencies = {
+        eslint: versions_1.eslintVersion,
+        'eslint-config-prettier': versions_1.eslintConfigPrettierVersion,
+        'typescript-eslint': versions_1.typescriptESLintVersion,
+        '@typescript-eslint/eslint-plugin': versions_1.typescriptESLintVersion,
+        '@typescript-eslint/parser': versions_1.typescriptESLintVersion,
+    };
+    if ((0, devkit_1.getDependencyVersionFromPackageJson)(tree, '@typescript-eslint/utils')) {
+        devDependencies['@typescript-eslint/utils'] = versions_1.typescriptESLintVersion;
+    }
+    if ((0, devkit_1.getDependencyVersionFromPackageJson)(tree, '@typescript-eslint/type-utils')) {
+        devDependencies['@typescript-eslint/type-utils'] = versions_1.typescriptESLintVersion;
+    }
+    // add missing packages
+    if (addESLintRC) {
+        devDependencies['@eslint/eslintrc'] = versions_1.eslintrcVersion;
+    }
+    if (addESLintJS) {
+        devDependencies['@eslint/js'] = versions_1.eslintVersion;
+    }
+    // Convert-to-flat-config is an opt-in "upgrade" — we intentionally overwrite
+    // existing pins to land the workspace on the latest flat-config-ready stack.
+    (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies);
+}

package/{src → dist/src}/generators/convert-to-flat-config/schema.json

@@ -10,6 +10,13 @@
       "description": "Skip formatting files.",
       "default": false,
       "x-priority": "internal"
+    },
+    "eslintConfigFormat": {
+      "type": "string",
+      "description": "The format of the generated ESLint flat config files.",
+      "enum": ["mjs", "cjs"],
+      "default": "mjs",
+      "x-priority": "internal"
     }
   },
   "additionalProperties": false,

package/{src → dist/src}/generators/convert-to-inferred/convert-to-inferred.d.ts

@@ -5,4 +5,3 @@ interface Schema {
 }
 export declare function convertToInferred(tree: Tree, options: Schema): Promise<void>;
 export default convertToInferred;
-//# sourceMappingURL=convert-to-inferred.d.ts.map

package/{src → dist/src}/generators/convert-to-inferred/convert-to-inferred.js

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertToInferred = convertToInferred;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const executor_to_plugin_migrator_1 = require("@nx/devkit/src/generators/plugin-migrations/executor-to-plugin-migrator");
-const plugin_migration_utils_1 = require("@nx/devkit/src/generators/plugin-migrations/plugin-migration-utils");
 const posix_1 = require("node:path/posix");
 const utils_1 = require("nx/src/tasks-runner/utils");
 const plugin_1 = require("../../plugins/plugin");
+const assert_supported_eslint_version_1 = require("../../utils/assert-supported-eslint-version");
 const config_file_1 = require("../../utils/config-file");
 const target_options_map_1 = require("./lib/target-options-map");
 async function convertToInferred(tree, options) {
+    (0, assert_supported_eslint_version_1.assertSupportedEslintVersion)(tree);
     const projectGraph = await (0, devkit_1.createProjectGraphAsync)();
-    const migratedProjects = await (0, executor_to_plugin_migrator_1.migrateProjectExecutorsToPlugin)(tree, projectGraph, '@nx/eslint/plugin', plugin_1.createNodesV2, { targetName: 'lint' }, [
+    const migratedProjects = await (0, internal_1.migrateProjectExecutorsToPlugin)(tree, projectGraph, '@nx/eslint/plugin', plugin_1.createNodes, { targetName: 'lint' }, [
         {
             executors: ['@nx/eslint:lint', '@nrwl/linter:eslint'],
             postTargetTransformer,
@@ -20,7 +21,7 @@ async function convertToInferred(tree, options) {
         },
     ], options.project);
     if (migratedProjects.size === 0) {
-        throw new executor_to_plugin_migrator_1.NoTargetsToMigrateError();
+        throw new internal_1.NoTargetsToMigrateError();
     }
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
@@ -75,7 +76,7 @@ function postTargetTransformer(target, tree, projectDetails, inferredTargetConfi
         }
     }
     if (target.outputs) {
-        (0, plugin_migration_utils_1.processTargetOutputs)(target, [], inferredTargetConfiguration, {
+        (0, internal_1.processTargetOutputs)(target, [], inferredTargetConfiguration, {
             projectName: projectDetails.projectName,
             projectRoot: projectDetails.root,
         });

package/{src → dist/src}/generators/convert-to-inferred/lib/target-options-map.d.ts

@@ -14,4 +14,3 @@ export declare const targetOptionsToCliMap: {
     reportUnusedDisableDirectives: string;
     printConfig: string;
 };
-//# sourceMappingURL=target-options-map.d.ts.map

package/{src → dist/src}/generators/init/global-eslint-config.d.ts

@@ -27,4 +27,3 @@ export declare const javaScriptOverride: {
 };
 export declare const getGlobalEsLintConfiguration: (unitTestRunner?: string, rootProject?: boolean) => Linter.LegacyConfig;
 export declare const getGlobalFlatEslintConfiguration: (format: "cjs" | "mjs", rootProject?: boolean) => string;
-//# sourceMappingURL=global-eslint-config.d.ts.map

package/{src → dist/src}/generators/init/init-migration.d.ts

@@ -1,4 +1,3 @@
 import { GeneratorCallback, ProjectConfiguration, TargetConfiguration, Tree } from '@nx/devkit';
 export declare function migrateConfigToMonorepoStyle(projects: ProjectConfiguration[], tree: Tree, unitTestRunner: string, eslintConfigFormat: 'mjs' | 'cjs', keepExistingVersions?: boolean): GeneratorCallback;
 export declare function findLintTarget(project: ProjectConfiguration): TargetConfiguration;
-//# sourceMappingURL=init-migration.d.ts.map

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

@@ -34,9 +34,10 @@ function migrateConfigToMonorepoStyle(projects, tree, unitTestRunner, eslintConf
     else {
         if ((0, flat_config_1.useFlatConfig)(tree)) {
             // we need this for the compat
+            const { eslintVersion } = (0, versions_1.versions)(tree);
             (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
-                '@eslint/js': versions_1.eslintVersion,
-            }, undefined, keepExistingVersions);
+                '@eslint/js': eslintVersion,
+            }, undefined, keepExistingVersions ?? true);
             tree.write(tree.exists(`eslint.config.${eslintConfigFormat}`)
                 ? `eslint.base.config.${eslintConfigFormat}`
                 : `eslint.config.${eslintConfigFormat}`, (0, global_eslint_config_1.getGlobalFlatEslintConfiguration)(eslintConfigFormat));
@@ -77,7 +78,7 @@ function migrateConfigToMonorepoStyle(projects, tree, unitTestRunner, eslintConf
     });
     return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
         '@nx/eslint-plugin': versions_1.nxVersion,
-    });
+    }, undefined, keepExistingVersions ?? true);
 }
 function findLintTarget(project) {
     return Object.values(project.targets ?? {}).find((target) => target.executor === '@nx/eslint:lint' ||

package/{src → dist/src}/generators/init/init.d.ts

@@ -8,4 +8,3 @@ export interface LinterInitOptions {
 }
 export declare function initEsLint(tree: Tree, options: LinterInitOptions): Promise<GeneratorCallback>;
 export declare function lintInitGenerator(tree: Tree, options: LinterInitOptions): Promise<GeneratorCallback>;
-//# sourceMappingURL=init.d.ts.map