@nx/eslint 23.1.0-beta.4 → 23.1.0-beta.5

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

@@ -8,6 +8,7 @@ const path_1 = require("path");
 const assert_supported_eslint_version_1 = require("../../utils/assert-supported-eslint-version");
 const versions_1 = require("../../utils/versions");
 const config_file_1 = require("../../utils/config-file");
+const semver_1 = require("semver");
 const json_converter_1 = require("./converters/json-converter");
 async function convertToFlatConfigGenerator(tree, options) {
     (0, assert_supported_eslint_version_1.assertSupportedEslintVersion)(tree);
@@ -65,6 +66,25 @@ function isEslintTarget(target) {
     return (target.executor === ESLINT_LINT_EXECUTOR ||
         target.command?.includes('eslint'));
 }
+function hasMatchingEslintTargetDefault(projectConfig, targetDefaults) {
+    if (!projectConfig.targets || !targetDefaults) {
+        return false;
+    }
+    return Object.entries(targetDefaults).some(([targetName, value]) => {
+        if (projectConfig.targets[targetName] === undefined) {
+            return false;
+        }
+        if (targetName === ESLINT_LINT_EXECUTOR) {
+            return true;
+        }
+        // A target default value can be a plain config object or an array of
+        // filtered entries; match against the filter-less (catch-all) entry.
+        const targetConfig = Array.isArray(value)
+            ? value.find((e) => e.filter === undefined)
+            : value;
+        return targetConfig ? isEslintTarget(targetConfig) : false;
+    });
+}
 function convertProjectToFlatConfig(tree, project, projectConfig, nxJson, eslintIgnoreFiles, format, keepExistingVersions) {
     const eslintFile = (0, eslint_file_1.findEslintFile)(tree, projectConfig.root);
     if (!eslintFile) {
@@ -95,10 +115,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)) {
@@ -148,20 +165,33 @@ function ensureInputPresent(inputs, value, format) {
 }
 // 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).
+// (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) {
-            for (const [name, target] of Object.entries(json.targetDefaults)) {
-                if (!target.inputs)
-                    continue;
+            for (const [name, value] of Object.entries(json.targetDefaults)) {
                 const isLintTarget = name === 'lint' || name === ESLINT_LINT_EXECUTOR;
-                target.inputs = isLintTarget
-                    ? ensureInputPresent(target.inputs, `{workspaceRoot}/eslint.config.${format}`, format)
-                    : rewriteLegacyInputs(target.inputs, format);
+                // A target default value can be a plain config object or an array of
+                // filtered entries; rewrite inputs on each entry in the array case.
+                if (Array.isArray(value)) {
+                    for (const entry of value) {
+                        rewriteTargetInputs(entry, isLintTarget);
+                    }
+                }
+                else {
+                    rewriteTargetInputs(value, isLintTarget);
+                }
             }
         }
         if (json.namedInputs) {
@@ -256,9 +286,26 @@ function processConvertedConfig(tree, root, source, target, { content, addESLint
     if (addESLintJS) {
         devDependencies['@eslint/js'] = versions_1.eslintVersion;
     }
+    // The flat/angular presets import the umbrella `angular-eslint` package; add
+    // it when the converted config references them so the result resolves.
+    if (content.includes('flat/angular')) {
+        devDependencies['angular-eslint'] = resolveAngularEslintVersion(tree);
+    }
     // Direct invocation is an opt-in upgrade, so by default existing pins are
     // overwritten to land the workspace on the latest flat-config-ready stack.
     // Migrations pass `keepExistingVersions` so the version bump stays owned by
     // `packageJsonUpdates` and only newly added packages are installed here.
     (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, 'package.json', keepExistingVersions);
 }
+// The umbrella `angular-eslint` and the scoped `@angular-eslint/*` packages
+// release in lockstep, so pin the umbrella to the major already installed,
+// falling back to the latest major nx generates when none is present. @nx/eslint
+// can't read the canonical pin from @nx/angular without inverting the package
+// dependency (@nx/angular depends on @nx/eslint), so the fallback is hardcoded;
+// keep it in sync with `angularEslintVersion` in packages/angular/src/utils/versions.ts.
+function resolveAngularEslintVersion(tree) {
+    const installed = (0, devkit_1.getDependencyVersionFromPackageJson)(tree, '@angular-eslint/eslint-plugin') ??
+        (0, devkit_1.getDependencyVersionFromPackageJson)(tree, '@angular-eslint/template-parser');
+    const installedMajor = installed ? (0, semver_1.coerce)(installed)?.major : undefined;
+    return installedMajor != null ? `^${installedMajor}.0.0` : '^22.0.0';
+}

package/dist/src/generators/init/init.js

@@ -22,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')) {

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

@@ -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
@@ -92,3 +93,18 @@ async function lintWorkspaceRulesProjectGenerator(tree, options = {}) {
     }
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
+function findLintTargetDefault(td) {
+    const value = td?.['lint'];
+    if (value === undefined)
+        return undefined;
+    // A target default value can be a plain config object or an array of
+    // filtered entries; use the filter-less (catch-all) entry.
+    if (Array.isArray(value)) {
+        const found = value.find((e) => e.filter === undefined);
+        if (!found)
+            return undefined;
+        const { filter: _filter, ...rest } = found;
+        return rest;
+    }
+    return value;
+}

package/dist/src/migrations/update-21-6-0/update-executor-lint-inputs.js

@@ -2,13 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = default_1;
 const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
 async function default_1(tree) {
-    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const nxJson = (0, devkit_1.readNxJson)(tree) ?? {};
     const executor = '@nx/eslint:lint';
-    if (!nxJson.targetDefaults?.[executor]?.inputs) {
+    const existing = (0, internal_1.findTargetDefault)(nxJson.targetDefaults, { executor });
+    if (!existing?.inputs) {
         return;
     }
-    const inputs = nxJson.targetDefaults[executor].inputs;
+    const inputs = [...existing.inputs];
     if (!inputs.includes('^default')) {
         // Add after 'default' if present, otherwise at the beginning
         const defaultIndex = inputs.indexOf('default');
@@ -22,6 +24,7 @@ async function default_1(tree) {
     if (!inputs.includes('{workspaceRoot}/tools/eslint-rules/**/*')) {
         inputs.push('{workspaceRoot}/tools/eslint-rules/**/*');
     }
+    (0, internal_1.upsertTargetDefault)(tree, nxJson, { executor, inputs });
     (0, devkit_1.updateNxJson)(tree, nxJson);
     await (0, devkit_1.formatFiles)(tree);
 }

package/dist/src/migrations/update-23-1-0/convert-to-flat-config.js

@@ -181,6 +181,10 @@ function findRemovedFormatterTargets(tree) {
         if (name !== 'lint' && name !== ESLINT_LINT_EXECUTOR) {
             continue;
         }
+        if (Array.isArray(target)) {
+            // This migration predates the filtered array value form; values are plain objects here.
+            continue;
+        }
         const optionSets = [[null, target.options], ...Object.entries(target.configurations ?? {})];
         collectRemovedFormatters(`targetDefaults["${name}"]`, optionSets);
     }
@@ -231,6 +235,10 @@ function findUnsupportedFlatConfigOptionTargets(tree) {
         if (name !== 'lint' && name !== ESLINT_LINT_EXECUTOR) {
             continue;
         }
+        if (Array.isArray(target)) {
+            // This migration predates the filtered array value form; values are plain objects here.
+            continue;
+        }
         const optionSets = [[null, target.options], ...Object.entries(target.configurations ?? {})];
         collect(`targetDefaults["${name}"]`, optionSets, FLAT_CONFIG_UNSUPPORTED_OPTIONS);
     }

package/dist/src/migrations/update-23-1-0/migrate-ban-types-rule.md

@@ -0,0 +1,15 @@
+# Migrate the removed `@typescript-eslint/ban-types` rule
+
+typescript-eslint v8 removed `@typescript-eslint/ban-types`, so an ESLint flat
+config that still references it fails to load. It was split into three rules:
+
+- `@typescript-eslint/no-empty-object-type` - the `{}` type
+- `@typescript-eslint/no-unsafe-function-type` - the `Function` type
+- `@typescript-eslint/no-wrapper-object-types` - wrapper types (`String`, `Number`, `Boolean`, `Object`, ...)
+
+In every ESLint flat config (`eslint.config.{mjs,cjs,js,cts,ts,mts}`) that sets
+`@typescript-eslint/ban-types`, replace that single entry with the three rules
+above. The options do not map 1:1: if the old entry was just `'error'`/`'warn'`,
+set all three to that level; if it customized `types`/`extendDefaults`, translate
+the intent to whichever successor rule covers each banned type and drop anything
+with no equivalent. Then run `nx run-many -t lint` and confirm the configs load.

package/dist/src/migrations/update-23-1-0/remove-removed-typescript-eslint-extension-rules.d.ts

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

package/dist/src/migrations/update-23-1-0/remove-removed-typescript-eslint-extension-rules.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const ts = tslib_1.__importStar(require("typescript"));
+// Inlined rather than imported from the @nx/eslint utils so this migration stays
+// self-contained - a migration should not depend on a shared list that can change
+// in a later version.
+const ESLINT_FLAT_CONFIG_FILENAMES = [
+    'eslint.config.cjs',
+    'eslint.config.js',
+    'eslint.config.mjs',
+    'eslint.config.cts',
+    'eslint.config.ts',
+    'eslint.config.mts',
+];
+// Formatting/extension rules typescript-eslint removed in v8 (moved to
+// @stylistic). A flat config that still references one fails to load: "Could not
+// find <rule> in plugin @typescript-eslint".
+//
+// These are DELETED, not rewritten to the base ESLint rule (e.g.
+// `@typescript-eslint/no-extra-semi` -> `no-extra-semi`), on purpose: the base
+// equivalents are themselves deprecated and frozen in ESLint 9 (slated for
+// removal), so resurrecting one just defers the same break to the next ESLint
+// major. And Prettier - which nx workspaces run - already enforces this
+// formatting, so the rules were redundant. The long-term home is @stylistic,
+// which we will not auto-add as a dependency.
+const REMOVED_TS_ESLINT_RULES = new Set([
+    'block-spacing',
+    'brace-style',
+    'comma-dangle',
+    'comma-spacing',
+    'func-call-spacing',
+    'indent',
+    'key-spacing',
+    'keyword-spacing',
+    'lines-around-comment',
+    'lines-between-class-members',
+    'member-delimiter-style',
+    'no-extra-parens',
+    'no-extra-semi',
+    'object-curly-spacing',
+    'padding-line-between-statements',
+    'quotes',
+    'semi',
+    'space-before-blocks',
+    'space-before-function-paren',
+    'space-infix-ops',
+    'type-annotation-spacing',
+].map((rule) => `@typescript-eslint/${rule}`));
+// Semantic rules typescript-eslint renamed 1:1 in v8. Unlike the formatting
+// rules these enforce real behavior, so we rewrite the key to the successor to
+// preserve enforcement rather than drop it.
+//
+// `ban-types` is intentionally NOT here: it split into three rules
+// (no-empty-object-type, no-unsafe-function-type, no-wrapper-object-types) whose
+// options do not map cleanly, so it is handled by the companion prompt-based
+// migration instead.
+const RENAMED_TS_ESLINT_RULES = new Map([
+    [
+        '@typescript-eslint/no-throw-literal',
+        '@typescript-eslint/only-throw-error',
+    ],
+    [
+        '@typescript-eslint/no-useless-template-literals',
+        '@typescript-eslint/no-unnecessary-template-expression',
+    ],
+]);
+async function update(tree) {
+    let changed = false;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (path) => {
+        const fileName = path.split('/').pop();
+        if (!ESLINT_FLAT_CONFIG_FILENAMES.includes(fileName)) {
+            return;
+        }
+        const content = tree.read(path, 'utf-8');
+        if (!content?.includes('@typescript-eslint/')) {
+            return;
+        }
+        const source = ts.createSourceFile(path, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+        // {start, end, newText} edits, applied high offset -> low so earlier offsets
+        // stay valid. Covers both deletes (newText '') and key rewrites uniformly.
+        const edits = [];
+        const visit = (node) => {
+            if (ts.isPropertyAssignment(node) &&
+                (ts.isStringLiteral(node.name) ||
+                    ts.isNoSubstitutionTemplateLiteral(node.name))) {
+                const ruleName = node.name.text;
+                if (REMOVED_TS_ESLINT_RULES.has(ruleName)) {
+                    // Remove the whole rule entry, including its leading whitespace and the
+                    // trailing comma, so the surrounding rules object stays valid.
+                    let end = node.end;
+                    const trailingComma = content.slice(end).match(/^\s*,/);
+                    if (trailingComma) {
+                        end += trailingComma[0].length;
+                    }
+                    edits.push({ start: node.getFullStart(), end, newText: '' });
+                }
+                else if (RENAMED_TS_ESLINT_RULES.has(ruleName)) {
+                    // Rewrite only the key, preserving the existing quote style and value.
+                    const keyStart = node.name.getStart(source);
+                    const quote = content[keyStart];
+                    edits.push({
+                        start: keyStart,
+                        end: node.name.getEnd(),
+                        newText: `${quote}${RENAMED_TS_ESLINT_RULES.get(ruleName)}${quote}`,
+                    });
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(source);
+        if (edits.length) {
+            edits.sort((a, b) => b.start - a.start);
+            let updated = content;
+            for (const edit of edits) {
+                updated =
+                    updated.slice(0, edit.start) + edit.newText + updated.slice(edit.end);
+            }
+            tree.write(path, updated);
+            changed = true;
+        }
+    });
+    if (changed) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}

package/migrations.json

@@ -24,6 +24,22 @@
       "description": "Convert remaining ESLint configs to flat config for ESLint v9 and keep the workspace lint-passing, disabling rules whose preset defaults changed.",
       "implementation": "./dist/src/migrations/update-23-1-0/convert-to-flat-config",
       "prompt": "./dist/src/migrations/update-23-1-0/convert-to-flat-config.md"
+    },
+    "update-23-1-0-remove-removed-typescript-eslint-extension-rules": {
+      "version": "23.1.0-beta.5",
+      "requires": {
+        "typescript-eslint": ">=8.0.0"
+      },
+      "description": "Handle typescript-eslint rules removed in v8 in ESLint flat configs, since referencing a removed rule stops the config from loading. Deletes the removed formatting/extension rules (e.g. @typescript-eslint/no-extra-semi) and rewrites the safe 1:1 renames (no-throw-literal -> only-throw-error, no-useless-template-literals -> no-unnecessary-template-expression) to preserve enforcement.",
+      "implementation": "./dist/src/migrations/update-23-1-0/remove-removed-typescript-eslint-extension-rules"
+    },
+    "update-23-1-0-migrate-ban-types-rule": {
+      "version": "23.1.0-beta.5",
+      "requires": {
+        "typescript-eslint": ">=8.0.0"
+      },
+      "description": "Migrate the removed @typescript-eslint/ban-types rule to its v8 successors (no-empty-object-type, no-unsafe-function-type, no-wrapper-object-types), whose options do not map 1:1 - so it is driven by an AI prompt rather than a deterministic codemod.",
+      "prompt": "./dist/src/migrations/update-23-1-0/migrate-ban-types-rule.md"
     }
   },
   "packageJsonUpdates": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/eslint",
-  "version": "23.1.0-beta.4",
+  "version": "23.1.0-beta.5",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -73,17 +73,17 @@
   "peerDependencies": {
     "@zkochan/js-yaml": "0.0.7",
     "eslint": "^9.0.0 || ^10.0.0",
-    "@nx/jest": "23.1.0-beta.4"
+    "@nx/jest": "23.1.0-beta.5"
   },
   "dependencies": {
     "semver": "^7.6.3",
     "tslib": "^2.3.0",
     "typescript": "~6.0.3",
-    "@nx/devkit": "23.1.0-beta.4",
-    "@nx/js": "23.1.0-beta.4"
+    "@nx/devkit": "23.1.0-beta.5",
+    "@nx/js": "23.1.0-beta.5"
   },
   "devDependencies": {
-    "nx": "23.1.0-beta.4"
+    "nx": "23.1.0-beta.5"
   },
   "peerDependenciesMeta": {
     "@nx/jest": {