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

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,8 @@
+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, getTypeScriptEslintVersionToInstall, } from './src/utils/version-utils';
+export { eslint9__typescriptESLintVersion } from './src/utils/versions';
+export type { Schema } from './src/executors/lint/schema';

package/dist/internal.js

@@ -0,0 +1,34 @@
+"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.eslint9__typescriptESLintVersion = exports.getTypeScriptEslintVersionToInstall = 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 version_utils_1 = require("./src/utils/version-utils");
+Object.defineProperty(exports, "getInstalledEslintVersion", { enumerable: true, get: function () { return version_utils_1.getInstalledEslintVersion; } });
+Object.defineProperty(exports, "getTypeScriptEslintVersionToInstall", { enumerable: true, get: function () { return version_utils_1.getTypeScriptEslintVersionToInstall; } });
+var versions_1 = require("./src/utils/versions");
+Object.defineProperty(exports, "eslint9__typescriptESLintVersion", { enumerable: true, get: function () { return versions_1.eslint9__typescriptESLintVersion; } });

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

@@ -7,7 +7,9 @@ const utils_1 = require("nx/src/tasks-runner/utils");
 const path_1 = require("path");
 const config_file_1 = require("../../utils/config-file");
 const eslint_utils_1 = require("./utility/eslint-utils");
+const deprecation_1 = require("../../utils/deprecation");
 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;

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/{src → dist/src}/generators/convert-to-flat-config/generator.js

@@ -28,8 +28,9 @@ async function convertToFlatConfigGenerator(tree, options) {
     for (const ignoreFile of eslintIgnoreFiles) {
         tree.delete(ignoreFile);
     }
-    // replace references in nx.json
+    // 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);
@@ -48,6 +49,18 @@ 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')) {
@@ -70,10 +83,7 @@ function convertProjectToFlatConfig(tree, project, projectConfig, nxJson, eslint
     if (eslintTargets.length > 0) {
         (0, devkit_1.updateProjectConfiguration)(tree, project, projectConfig);
     }
-    const hasEslintTargetDefaults = projectConfig.targets &&
-        Object.keys(nxJson.targetDefaults || {}).some((t) => (t === ESLINT_LINT_EXECUTOR ||
-            isEslintTarget(nxJson.targetDefaults[t])) &&
-            projectConfig.targets[t]);
+    const hasEslintTargetDefaults = hasMatchingEslintTargetDefault(projectConfig, nxJson.targetDefaults);
     if (eslintTargets.length === 0 &&
         !hasEslintTargetDefaults &&
         !(0, plugin_1.hasEslintPlugin)(tree)) {
@@ -86,35 +96,120 @@ function convertProjectToFlatConfig(tree, project, projectConfig, nxJson, eslint
         eslintIgnoreFiles.add(ignorePath);
     }
 }
-// update names of eslint files in nx.json
-// and remove eslintignore
+// 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')) {
-        (0, devkit_1.updateJson)(tree, 'nx.json', (json) => {
-            if (json.targetDefaults?.lint?.inputs) {
-                const inputSet = new Set(json.targetDefaults.lint.inputs);
-                inputSet.add(`{workspaceRoot}/eslint.config.${format}`);
-                json.targetDefaults.lint.inputs = Array.from(inputSet);
+    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);
+                }
             }
-            if (json.targetDefaults?.['@nx/eslint:lint']?.inputs) {
-                const inputSet = new Set(json.targetDefaults['@nx/eslint:lint'].inputs);
-                inputSet.add(`{workspaceRoot}/eslint.config.${format}`);
-                json.targetDefaults['@nx/eslint:lint'].inputs = Array.from(inputSet);
+            else {
+                for (const [name, target] of Object.entries(json.targetDefaults)) {
+                    const isLintTarget = name === 'lint' || name === ESLINT_LINT_EXECUTOR;
+                    rewriteTargetInputs(target, isLintTarget);
+                }
             }
-            if (json.namedInputs?.production) {
-                const inputSet = new Set(json.namedInputs.production);
-                inputSet.add(`!{projectRoot}/eslint.config.${format}`);
-                json.namedInputs.production = Array.from(inputSet);
+        }
+        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;
-        });
+        }
+        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`];
-    if (source.endsWith('.json')) {
+    // `.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);

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,9 +1,8 @@
 "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");
@@ -11,7 +10,7 @@ const config_file_1 = require("../../utils/config-file");
 const target_options_map_1 = require("./lib/target-options-map");
 async function convertToInferred(tree, options) {
     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.createNodesV2, { targetName: 'lint' }, [
         {
             executors: ['@nx/eslint:lint', '@nrwl/linter:eslint'],
             postTargetTransformer,
@@ -20,7 +19,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 +74,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.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

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

@@ -2,8 +2,8 @@
 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 versions_1 = require("../../utils/versions");
 const eslint_file_1 = require("../utils/eslint-file");
 const plugin_1 = require("../../plugins/plugin");
@@ -21,19 +21,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')) {
@@ -75,7 +88,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 +99,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);
     }

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