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

package/dist/src/generators/convert-to-flat-config/angular-eslint.d.ts

@@ -0,0 +1,20 @@
+import { type Tree } from '@nx/devkit';
+/**
+ * Reconciles converted flat configs with angular-eslint v22's breaking changes so
+ * they load again. The converter carries the removed `plugin:@angular-eslint/*`
+ * configs as FlatCompat shims in two shapes: a bare `...compat.extends(...)` for
+ * top-level extends, and a `...compat.config({ extends }).map(...)` for per-override
+ * extends. This handles both: shared configs become their flat-native
+ * `angular.configs.*` counterparts, and `process-inline-templates` becomes a
+ * `processor` block. The per-override shape drops that block when `flat/angular`
+ * already applies the processor; the top-level shape keeps it. It also drops the
+ * removed `no-conflicting-lifecycle` rule, injects the `angular-eslint` import
+ * (and dependency) when it introduces `angular.*` references, and removes the
+ * FlatCompat scaffolding left unused afterwards.
+ *
+ * Gated on angular-eslint v22+: the shims resolve on v18-v21, so rewriting them
+ * there would be churn, and only the v22 flat exports are known here. Does not
+ * format; the caller owns formatting.
+ */
+export declare function migrateAngularEslintV22FlatConfig(tree: Tree): Promise<void>;
+export declare function resolveAngularEslintVersion(tree: Tree): string;

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

@@ -0,0 +1,410 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateAngularEslintV22FlatConfig = migrateAngularEslintV22FlatConfig;
+exports.resolveAngularEslintVersion = resolveAngularEslintVersion;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const semver_1 = require("semver");
+const ts = tslib_1.__importStar(require("typescript"));
+const config_file_1 = require("../../utils/config-file");
+const ast_utils_1 = require("../utils/flat-config/ast-utils");
+// angular-eslint v22 dropped the legacy eslintrc config format, so every
+// `plugin:@angular-eslint/*` shared config stops resolving. The converter emits
+// them as `compat.extends(...)` shims (it maps only `plugin:@nx/*` natively), so
+// those shims fail to load. Each removed eslintrc config has a flat-native
+// counterpart on the umbrella `angular-eslint` package; remap the shims to it.
+const ANGULAR_ESLINT_CONFIG_MAP = {
+    'plugin:@angular-eslint/recommended': 'tsRecommended',
+    'plugin:@angular-eslint/all': 'tsAll',
+    'plugin:@angular-eslint/template/recommended': 'templateRecommended',
+    'plugin:@angular-eslint/template/accessibility': 'templateAccessibility',
+    'plugin:@angular-eslint/template/all': 'templateAll',
+};
+// Not a shared config but a processor: v22 exposes it as `processInlineTemplates`,
+// applied via a `{ files, processor }` block rather than an extends spread.
+const PROCESS_INLINE_TEMPLATES = 'plugin:@angular-eslint/template/process-inline-templates';
+// angular-eslint v22 removed this rule; a config that still lists it throws on
+// load: "Could not find no-conflicting-lifecycle in plugin @angular-eslint".
+const REMOVED_RULE = '@angular-eslint/no-conflicting-lifecycle';
+const FLAT_CONFIG_FILENAMES = new Set([
+    ...config_file_1.ESLINT_FLAT_CONFIG_FILENAMES,
+    ...config_file_1.BASE_ESLINT_CONFIG_FILENAMES,
+]);
+/**
+ * Reconciles converted flat configs with angular-eslint v22's breaking changes so
+ * they load again. The converter carries the removed `plugin:@angular-eslint/*`
+ * configs as FlatCompat shims in two shapes: a bare `...compat.extends(...)` for
+ * top-level extends, and a `...compat.config({ extends }).map(...)` for per-override
+ * extends. This handles both: shared configs become their flat-native
+ * `angular.configs.*` counterparts, and `process-inline-templates` becomes a
+ * `processor` block. The per-override shape drops that block when `flat/angular`
+ * already applies the processor; the top-level shape keeps it. It also drops the
+ * removed `no-conflicting-lifecycle` rule, injects the `angular-eslint` import
+ * (and dependency) when it introduces `angular.*` references, and removes the
+ * FlatCompat scaffolding left unused afterwards.
+ *
+ * Gated on angular-eslint v22+: the shims resolve on v18-v21, so rewriting them
+ * there would be churn, and only the v22 flat exports are known here. Does not
+ * format; the caller owns formatting.
+ */
+async function migrateAngularEslintV22FlatConfig(tree) {
+    if (!isAngularEslintV22OrLater(tree)) {
+        return;
+    }
+    let needsAngularDependency = false;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (path) => {
+        const fileName = path.split('/').pop();
+        if (!fileName || !FLAT_CONFIG_FILENAMES.has(fileName)) {
+            return;
+        }
+        const content = tree.read(path, 'utf-8');
+        if (!content || !referencesRemovedAngularEslint(content)) {
+            return;
+        }
+        const { updated, introducedAngularRef } = rewriteContent(content);
+        if (updated !== content) {
+            tree.write(path, updated);
+            needsAngularDependency ||= introducedAngularRef;
+        }
+    });
+    if (needsAngularDependency) {
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { 'angular-eslint': resolveAngularEslintVersion(tree) }, 'package.json', true);
+    }
+}
+// The umbrella `angular-eslint` and the scoped `@angular-eslint/*` packages
+// release in lockstep, so any one reflects the declared version. `nx migrate`
+// writes the version bump before migrations run, and the standalone generator
+// reads the currently installed version; either way package.json is the source.
+function readAngularEslintVersion(tree) {
+    return ((0, devkit_1.getDependencyVersionFromPackageJson)(tree, '@angular-eslint/eslint-plugin') ??
+        (0, devkit_1.getDependencyVersionFromPackageJson)(tree, 'angular-eslint') ??
+        (0, devkit_1.getDependencyVersionFromPackageJson)(tree, '@angular-eslint/template-parser'));
+}
+// 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 version = readAngularEslintVersion(tree);
+    const major = version ? (0, semver_1.coerce)(version)?.major : undefined;
+    return major != null ? `^${major}.0.0` : '^22.0.0';
+}
+function isAngularEslintV22OrLater(tree) {
+    const version = readAngularEslintVersion(tree);
+    const major = version ? (0, semver_1.coerce)(version)?.major : undefined;
+    return major != null && major >= 22;
+}
+// Cheap pre-filter so untouched configs are neither parsed nor rewritten.
+function referencesRemovedAngularEslint(content) {
+    return (content.includes(REMOVED_RULE) ||
+        content.includes(PROCESS_INLINE_TEMPLATES) ||
+        Object.keys(ANGULAR_ESLINT_CONFIG_MAP).some((config) => content.includes(config)));
+}
+function rewriteContent(content) {
+    // `flat/angular` (from `plugin:@nx/angular`) already applies the inline-template
+    // processor, so a process-inline-templates shim alongside it is redundant.
+    const flatAngularPresent = /flat\/angular['"]/.test(content);
+    // Rewrite the compat shims first, then drop the removed rule on the result: a
+    // rule can live inside a shim's `.map` body that pass 1 collapses, so doing
+    // both in one pass would collect overlapping edits.
+    const { updated: rewritten, introducedAngularRef } = rewriteAngularShims(content, flatAngularPresent);
+    const updated = removeRule(rewritten, REMOVED_RULE);
+    if (updated === content) {
+        return { updated: content, introducedAngularRef: false };
+    }
+    let cleaned = removeOrphanedFlatCompat(updated);
+    if (introducedAngularRef) {
+        cleaned = (0, ast_utils_1.addImportToFlatConfig)(cleaned, 'angular', 'angular-eslint');
+    }
+    return { updated: cleaned, introducedAngularRef };
+}
+// Rewrites both shapes the converter emits for angular-eslint extends: the bare
+// `...compat.extends(...)` spread (top-level extends) and the
+// `...compat.config({ extends: [...] }).map(...)` spread (per-override extends).
+function rewriteAngularShims(content, flatAngularPresent) {
+    const source = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+    const changes = [];
+    let introducedAngularRef = false;
+    const replaceSpread = (node, replacement) => {
+        const start = node.getStart(source);
+        changes.push({ type: devkit_1.ChangeType.Delete, start, length: node.end - start });
+        changes.push({ type: devkit_1.ChangeType.Insert, index: start, text: replacement });
+    };
+    const visit = (node) => {
+        if (ts.isSpreadElement(node) && ts.isCallExpression(node.expression)) {
+            // Shape 1: `...compat.extends('plugin:@angular-eslint/...', ...)`
+            if (node.expression.expression.getText(source) === 'compat.extends') {
+                const replacement = buildExtendsReplacement(node.expression.arguments);
+                if (replacement !== null) {
+                    replaceSpread(node, replacement);
+                    introducedAngularRef = true;
+                }
+            }
+            else {
+                // Shape 2: `...compat.config({ extends: [...] }).map(config => (...))`
+                const replacement = buildConfigOverrideReplacement(node, source, flatAngularPresent);
+                if (replacement !== null) {
+                    replaceSpread(node, replacement.text);
+                    introducedAngularRef ||= replacement.introducedAngularRef;
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return {
+        updated: changes.length ? (0, devkit_1.applyChangesToString)(content, changes) : content,
+        introducedAngularRef,
+    };
+}
+// Removes every `<rule>: ...` property assignment (with its trailing comma and
+// any trailing comment) so the config loads once the rule no longer exists.
+function removeRule(content, rule) {
+    const source = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+    const changes = [];
+    const visit = (node) => {
+        if (ts.isPropertyAssignment(node) &&
+            (ts.isStringLiteral(node.name) ||
+                ts.isNoSubstitutionTemplateLiteral(node.name)) &&
+            node.name.text === rule) {
+            // `getStart` (not `getFullStart`) so leading trivia is left intact; that
+            // trivia includes any trailing comment on the previous property.
+            const start = node.getStart(source);
+            changes.push({
+                type: devkit_1.ChangeType.Delete,
+                start,
+                length: consumeTrailingComma(content, node.end) - start,
+            });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return changes.length ? (0, devkit_1.applyChangesToString)(content, changes) : content;
+}
+// Sorts one `extends` entry into the flat-native config it maps to, the inline-
+// template processor, or an unrelated config left in a residual compat shim.
+// Shared by both shim builders so the classification lives in one place.
+function classifyExtend(value) {
+    const remapped = ANGULAR_ESLINT_CONFIG_MAP[value];
+    if (remapped) {
+        return { kind: 'remapped', config: remapped };
+    }
+    if (value === PROCESS_INLINE_TEMPLATES) {
+        return { kind: 'processor' };
+    }
+    return { kind: 'other', value };
+}
+// Rewrites the per-override shim shape
+// `...compat.config({ extends: [E] }).map(config => ({ ...config, files, rules }))`.
+// Shared configs in `extends` become `angular.configs.*` scoped to the override's
+// files; process-inline-templates becomes a processor block (dropped when
+// `flat/angular` already applies it). When `extends` empties, the
+// `compat.config(...).map(...)` wrapper collapses to the plain `{ files, rules }`
+// block it was scoping. Returns null when the block has no removed angular-eslint
+// config, or has a shape beyond a plain `{ extends }` object (left untouched
+// rather than risk corrupting it).
+function buildConfigOverrideReplacement(node, source, flatAngularPresent) {
+    const mapCall = node.expression;
+    // Structural match (not `getText`) so it survives prettier wrapping the
+    // `compat.config(...).map(...)` chain across lines in an already-formatted config.
+    if (!ts.isCallExpression(mapCall) ||
+        mapCall.arguments.length !== 1 ||
+        !ts.isArrowFunction(mapCall.arguments[0]) ||
+        !ts.isPropertyAccessExpression(mapCall.expression) ||
+        mapCall.expression.name.text !== 'map' ||
+        !ts.isCallExpression(mapCall.expression.expression)) {
+        return null;
+    }
+    const configCall = mapCall.expression.expression;
+    if (!ts.isPropertyAccessExpression(configCall.expression) ||
+        !ts.isIdentifier(configCall.expression.expression) ||
+        configCall.expression.expression.text !== 'compat' ||
+        configCall.expression.name.text !== 'config') {
+        return null;
+    }
+    // Only handle a plain `{ extends: [...string literals] }` object; a block that
+    // also carries plugins/env/etc. is left alone rather than partially rewritten.
+    const configArg = configCall.arguments[0];
+    if (!configArg || !ts.isObjectLiteralExpression(configArg)) {
+        return null;
+    }
+    const extendsProp = configArg.properties.find((prop) => ts.isPropertyAssignment(prop) &&
+        ts.isIdentifier(prop.name) &&
+        prop.name.text === 'extends');
+    if (!extendsProp ||
+        configArg.properties.length !== 1 ||
+        !ts.isArrayLiteralExpression(extendsProp.initializer) ||
+        !extendsProp.initializer.elements.every((el) => ts.isStringLiteral(el))) {
+        return null;
+    }
+    const remappedConfigs = [];
+    const otherConfigs = [];
+    let hasProcessor = false;
+    for (const element of extendsProp.initializer.elements) {
+        const classified = classifyExtend(element.text);
+        if (classified.kind === 'remapped') {
+            remappedConfigs.push(classified.config);
+        }
+        else if (classified.kind === 'processor') {
+            hasProcessor = true;
+        }
+        else {
+            otherConfigs.push(classified.value);
+        }
+    }
+    if (!remappedConfigs.length && !hasProcessor) {
+        return null;
+    }
+    const arrow = mapCall.arguments[0];
+    // The collapse branch strips the arrow's `...param` spreads by name, so the
+    // param must be a plain identifier; bail otherwise rather than mangle the body.
+    const mapParam = arrow.parameters[0]?.name;
+    if (!mapParam || !ts.isIdentifier(mapParam)) {
+        return null;
+    }
+    const paramName = mapParam.text;
+    const body = arrow.body;
+    if (!ts.isParenthesizedExpression(body) ||
+        !ts.isObjectLiteralExpression(body.expression)) {
+        return null;
+    }
+    const filesProp = body.expression.properties.find((prop) => ts.isPropertyAssignment(prop) &&
+        ts.isIdentifier(prop.name) &&
+        prop.name.text === 'files');
+    if (!filesProp) {
+        return null;
+    }
+    const filesText = filesProp.initializer.getText(source);
+    const elements = [];
+    let introducedAngularRef = false;
+    for (const config of remappedConfigs) {
+        // Scope the shared config to the override's files, as the `.map` did.
+        elements.push(`...angular.configs.${config}.map((c) => ({ ...c, files: ${filesText} }))`);
+        introducedAngularRef = true;
+    }
+    if (hasProcessor && !flatAngularPresent) {
+        elements.push(`{ files: ${filesText}, processor: angular.processInlineTemplates }`);
+        introducedAngularRef = true;
+    }
+    if (otherConfigs.length) {
+        // Unrelated configs stay in a compat.config, keeping the override's
+        // files/rules through the original callback.
+        elements.push(`...compat.config({ extends: [${otherConfigs
+            .map((config) => `'${config}'`)
+            .join(', ')}] }).map(${arrow.getText(source)})`);
+    }
+    else {
+        // Nothing left to extend: the `.map` only scoped the extended configs, so
+        // collapse it to the plain object it was building, dropping the arrow's now-
+        // orphaned `...param` / `...param.rules` spreads once the wrapper that bound
+        // the param is gone. The negative lookahead keeps `...param` from matching a
+        // longer identifier that merely starts with it.
+        const orphanedSpreads = new RegExp(`\\.\\.\\.${escapeRegExp(paramName)}(?![\\w$])(?:\\.rules)?\\s*,?\\s*`, 'g');
+        elements.push(body.expression.getText(source).replace(orphanedSpreads, ''));
+    }
+    return { text: elements.join(',\n'), introducedAngularRef };
+}
+// Rewrites a `compat.extends(...)` shim's arguments in place: each removed
+// angular-eslint config becomes an `angular.configs.*` spread, process-inline-
+// templates becomes a processor block, and any unrelated configs stay in a
+// residual `compat.extends`. Argument order is preserved (flat config is
+// last-wins, so reordering would change rule precedence). Returns the joined
+// replacement array elements, or null when no argument is a config nx removed
+// (leave the shim untouched).
+function buildExtendsReplacement(args) {
+    // The converter only ever emits string-literal arguments; bail on anything
+    // else rather than risk dropping an argument shape we don't understand.
+    if (!args.every((arg) => ts.isStringLiteral(arg))) {
+        return null;
+    }
+    const elements = [];
+    let pendingOtherConfigs = [];
+    let replacedAny = false;
+    // Emit the run of unrelated configs seen so far as one `compat.extends(...)`
+    // at their original position, so they keep their precedence relative to the
+    // remapped configs around them.
+    const flushOtherConfigs = () => {
+        if (pendingOtherConfigs.length) {
+            elements.push(`...compat.extends(${pendingOtherConfigs
+                .map((config) => `'${config}'`)
+                .join(', ')})`);
+            pendingOtherConfigs = [];
+        }
+    };
+    for (const arg of args) {
+        const classified = classifyExtend(arg.text);
+        if (classified.kind === 'remapped') {
+            flushOtherConfigs();
+            elements.push(`...angular.configs.${classified.config}`);
+            replacedAny = true;
+        }
+        else if (classified.kind === 'processor') {
+            flushOtherConfigs();
+            elements.push(`{ files: ['**/*.ts'], processor: angular.processInlineTemplates }`);
+            replacedAny = true;
+        }
+        else {
+            pendingOtherConfigs.push(classified.value);
+        }
+    }
+    flushOtherConfigs();
+    return replacedAny ? elements.join(',\n') : null;
+}
+// Extends past whitespace, comments, the trailing comma after `end`, and a
+// same-line comment after that comma so the enclosing object/array stays valid
+// after a deletion. Comments before the comma are skipped too: a comment between
+// the value and its comma would otherwise leave a dangling leading comma (a
+// syntax error); a comment after the comma belonged to the removed entry.
+function consumeTrailingComma(content, end) {
+    const trailing = content
+        .slice(end)
+        .match(/^(?:\s|\/\/[^\n]*\n?|\/\*[\s\S]*?\*\/)*,[ \t]*(?:\/\/[^\n]*)?/);
+    return trailing ? end + trailing[0].length : end;
+}
+// After the shims are rewritten, the `const compat = new FlatCompat(...)`
+// declaration, its `@eslint/eslintrc` import, and the `@eslint/js` import that
+// fed its `recommendedConfig` may be left unused. Drop each once nothing else
+// references it, so the config carries no dead FlatCompat scaffolding.
+function removeOrphanedFlatCompat(content) {
+    if (!content.includes('new FlatCompat')) {
+        return content;
+    }
+    const source = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+    const compatDeclaration = source.statements.find((node) => ts.isVariableStatement(node) &&
+        node.declarationList.declarations.some((decl) => ts.isIdentifier(decl.name) && decl.name.text === 'compat'));
+    // The declaration binding is itself one `compat` identifier; anything beyond
+    // it means the config still uses `compat`, so leave the scaffolding in place.
+    if (!compatDeclaration || countIdentifier(content, 'compat') > 1) {
+        return content;
+    }
+    let updated = content.slice(0, compatDeclaration.getFullStart()) +
+        content.slice(compatDeclaration.end);
+    updated = (0, ast_utils_1.removeImportFromFlatConfig)(updated, 'FlatCompat', '@eslint/eslintrc');
+    // FlatCompat's `recommendedConfig: js.configs.recommended` is usually the only
+    // use of `@eslint/js`; once the declaration is gone and nothing else
+    // references `js`, drop that import too.
+    if (countIdentifier(updated, 'js') <= 1) {
+        updated = (0, ast_utils_1.removeImportFromFlatConfig)(updated, 'js', '@eslint/js');
+    }
+    return updated;
+}
+// Counts identifiers with the given name (declarations, bindings, and
+// references alike) so callers can tell an orphaned binding from a live one.
+function countIdentifier(content, name) {
+    const source = ts.createSourceFile('', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+    let count = 0;
+    const visit = (node) => {
+        if (ts.isIdentifier(node) && node.text === name) {
+            count++;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return count;
+}
+// Escapes regex metacharacters so a dynamic identifier (an arrow parameter name)
+// can be matched literally. Identifiers can legitimately contain `$`.
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

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

@@ -9,6 +9,7 @@ const assert_supported_eslint_version_1 = require("../../utils/assert-supported-
 const versions_1 = require("../../utils/versions");
 const config_file_1 = require("../../utils/config-file");
 const json_converter_1 = require("./converters/json-converter");
+const angular_eslint_1 = require("./angular-eslint");
 async function convertToFlatConfigGenerator(tree, options) {
     (0, assert_supported_eslint_version_1.assertSupportedEslintVersion)(tree);
     // Already on flat config at the root? There is nothing to convert.
@@ -42,7 +43,10 @@ async function convertToFlatConfigGenerator(tree, options) {
     // replace references in nx.json and project.json files
     updateNxJsonConfig(tree, options.eslintConfigFormat);
     updateProjectConfigsInputs(tree, options.eslintConfigFormat);
-    // install missing packages
+    // The converter carries angular-eslint's removed eslintrc configs over as
+    // FlatCompat shims; on v22 those no longer resolve, so reconcile them to the
+    // flat-native config before formatting (no-op below v22).
+    await (0, angular_eslint_1.migrateAngularEslintV22FlatConfig)(tree);
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }
@@ -65,6 +69,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 +118,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 +168,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,6 +289,11 @@ 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'] = (0, angular_eslint_1.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

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/utils/flat-config/ast-utils.js

@@ -576,16 +576,23 @@ function removeImportFromFlatConfigESM(source, content, variable, imp) {
 function removeImportFromFlatConfigCJS(source, content, variable, imp) {
     const changes = [];
     ts.forEachChild(source, (node) => {
-        // we can only combine object binding patterns
-        if (ts.isVariableStatement(node) &&
-            ts.isVariableDeclaration(node.declarationList.declarations[0]) &&
-            ts.isIdentifier(node.declarationList.declarations[0].name) &&
-            node.declarationList.declarations[0].name.getText() === variable &&
-            ts.isCallExpression(node.declarationList.declarations[0].initializer) &&
-            node.declarationList.declarations[0].initializer.expression.getText() ===
-                'require' &&
-            ts.isStringLiteral(node.declarationList.declarations[0].initializer.arguments[0]) &&
-            node.declarationList.declarations[0].initializer.arguments[0].text === imp) {
+        if (!ts.isVariableStatement(node) ||
+            !ts.isVariableDeclaration(node.declarationList.declarations[0])) {
+            return;
+        }
+        const declaration = node.declarationList.declarations[0];
+        // Match both `const x = require(imp)` and a sole-binding
+        // `const { x } = require(imp)`, so an object-binding import is removed too.
+        const name = declaration.name;
+        const bindsVariable = (ts.isIdentifier(name) && name.getText() === variable) ||
+            (ts.isObjectBindingPattern(name) &&
+                name.elements.length === 1 &&
+                name.elements[0].name.getText() === variable);
+        if (bindsVariable &&
+            ts.isCallExpression(declaration.initializer) &&
+            declaration.initializer.expression.getText() === 'require' &&
+            ts.isStringLiteral(declaration.initializer.arguments[0]) &&
+            declaration.initializer.arguments[0].text === imp) {
             changes.push({
                 type: devkit_1.ChangeType.Delete,
                 start: node.pos,

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

@@ -4,6 +4,7 @@ exports.default = update;
 const devkit_1 = require("@nx/devkit");
 const config_file_1 = require("../../utils/config-file");
 const generator_1 = require("../../generators/convert-to-flat-config/generator");
+const angular_eslint_1 = require("../../generators/convert-to-flat-config/angular-eslint");
 // Output formatters ESLint removed in v9. Built-in names only; community
 // formatter packages (referenced by their package name) keep working.
 const REMOVED_FORMATTERS = new Set([
@@ -51,16 +52,24 @@ async function update(tree) {
     const removedFormatterTargets = findRemovedFormatterTargets(tree);
     const unsupportedOptionTargets = findUnsupportedFlatConfigOptionTargets(tree);
     const rootState = detectRootConfigState(tree);
-    if (rootState === 'none') {
-        // No ESLint configuration to migrate.
-        return;
-    }
     if (rootState === 'convertible') {
+        // The generator reconciles angular-eslint v22's removed configs as part of
+        // conversion, so the converted flat configs load without agent repair.
         await (0, generator_1.convertToFlatConfigGenerator)(tree, {
             keepExistingVersions: true,
-            skipFormat: false,
+            skipFormat: true,
         });
     }
+    // Reconcile angular-eslint v22's removed eslintrc configs in any flat config.
+    // Runs for every root state: project-level flat configs can exist even when the
+    // root is JavaScript-based (so the generator never ran), already flat, or
+    // absent. No-op for the converted root above (idempotent).
+    await (0, angular_eslint_1.migrateAngularEslintV22FlatConfig)(tree);
+    await (0, devkit_1.formatFiles)(tree);
+    if (rootState === 'none') {
+        // Nothing to migrate beyond the angular-eslint reconciliation above.
+        return;
+    }
     const agentContext = [
         passingBaselineInstruction(userExplicitRules),
     ];
@@ -181,6 +190,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 +244,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/convert-to-flat-config.md

@@ -179,7 +179,9 @@ The set of rules the user explicitly configured before the migration is in `<adv
    nx run-many -t lint
    ```
 
-2. For each rule that now reports errors:
+2. Tell a rule violation apart from a plugin crash. If a project fails with a thrown error instead of rule findings - a `TypeError` such as `context.getAncestors is not a function`, a `Could not find "<rule>" in plugin "<name>"` / `couldn't find the config "<name>" to extend from`, or a plugin that fails to load - the plugin predates ESLint v9; this is not a changed preset default. Do NOT disable the rule (that silently drops its coverage); update the plugin instead (section 6), then re-run lint and continue.
+
+3. For each rule that now reports errors (findings, not a thrown error):
    - If the rule ID is NOT in the user's explicit list, it came from a changed preset default. Disable it in the relevant flat config with a short comment explaining why.
    - If the rule ID IS in the user's explicit list, the user chose it. Leave it as-is and report it in your handoff summary.
 
@@ -200,6 +202,7 @@ export default [
 **Action items**:
 
 - [ ] Run lint and collect every newly reported rule.
+- [ ] Treat a plugin crash (a thrown error, not rule findings) as a version incompatibility: update the plugin (section 6), never disable its rules to silence it.
 - [ ] Disable preset-originated rules that the user did not configure.
 - [ ] Never disable or weaken a rule the user explicitly configured.
 - [ ] Never edit source files to satisfy a newly enabled rule.
@@ -240,6 +243,7 @@ npm install --save-dev eslint-formatter-junit
 
 - **Removed CLI flags and executor options**: `--rulesdir`, `--ext`, and `--resolve-plugins-relative-to` were removed. The matching `@nx/eslint:lint` options (`rulesdir`, `resolvePluginsRelativeTo`, `ignorePath`) are not supported for flat config. Move file targeting into the config via the `files` and `ignores` keys.
 - **No eslintrc auto-merge**: flat config does not merge `.eslintrc.*` files found up the tree. Every setting must live in `eslint.config.*`.
+- **Third-party plugins that predate ESLint v9**: an installed ESLint plugin that was not updated for v9 breaks at lint time - its rules call the removed `context` APIs below, or it only ships an eslintrc config that no longer loads. This surfaces as a thrown error (see section 4), not a new rule violation. List the installed plugins from `package.json` (`dependencies`/`devDependencies` matching `eslint-plugin-*` or `@<scope>/eslint-plugin-*`), and for each confirm its version supports ESLint v9 (its changelog, or that `peerDependencies.eslint` allows `>=9`). Update any that do not, and prefer the plugin's flat entry point where it ships one (for example `eslint-plugin-cypress/flat`). Update the plugin rather than disabling its rules.
 - **Local rule API moved to `SourceCode`** (only relevant if the workspace authors its own rules):
   - `context.getScope()` to `sourceCode.getScope(node)`
   - `context.getAncestors()` to `sourceCode.getAncestors(node)`
@@ -252,6 +256,7 @@ npm install --save-dev eslint-formatter-junit
 **Action items**:
 
 - [ ] Remove unsupported CLI flags and executor options; move targeting into `files` / `ignores`.
+- [ ] Update any installed third-party ESLint plugin that does not yet support ESLint v9, preferring its flat entry point; do not disable its rules to work around a load error.
 - [ ] Update local rules to the `SourceCode` API and add `meta.schema` where required.
 
 ---

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

@@ -0,0 +1,29 @@
+# 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`, ...)
+
+## First, check whether there is anything to do
+
+Confirm both conditions before changing anything. If either fails, make no
+changes and stop:
+
+1. Some ESLint flat config (`eslint.config.{mjs,cjs,js,cts,ts,mts}`) references
+   `@typescript-eslint/ban-types`. Search the workspace for that string; if no
+   config uses the rule, there is nothing to migrate.
+2. The workspace is on typescript-eslint v8 or later (check `typescript-eslint`
+   or `@typescript-eslint/eslint-plugin` in `package.json`). On v7 the rule
+   still exists, so leave it untouched.
+
+## Migrate
+
+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,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const semver_1 = require("semver");
+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. Includes the shared `eslint.base.config.*` files: they are
+// flat configs too and can carry the removed rules a project config inherits.
+const ESLINT_FLAT_CONFIG_FILENAMES = [
+    'eslint.config.cjs',
+    'eslint.config.js',
+    'eslint.config.mjs',
+    'eslint.config.cts',
+    'eslint.config.ts',
+    'eslint.config.mts',
+    'eslint.base.js',
+    'eslint.base.ts',
+    'eslint.base.config.cjs',
+    'eslint.base.config.js',
+    'eslint.base.config.mjs',
+    'eslint.base.config.cts',
+    'eslint.base.config.ts',
+    'eslint.base.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',
+    ],
+]);
+// The stripped rules only disappear in typescript-eslint v8. On v7 (or with
+// typescript-eslint absent) they are still valid, so editing a config would
+// wrongly drop a live rule. Gate on the umbrella `typescript-eslint` or the
+// scoped `@typescript-eslint/eslint-plugin` (a workspace declares one or the
+// other); the migration's JSON `requires` cannot express that OR.
+function hasTypescriptEslintV8(tree) {
+    return ['typescript-eslint', '@typescript-eslint/eslint-plugin'].some((pkg) => {
+        const version = (0, internal_1.getDeclaredPackageVersion)(tree, pkg);
+        return version !== null && (0, semver_1.major)(version) >= 8;
+    });
+}
+async function update(tree) {
+    if (!hasTypescriptEslintV8(tree)) {
+        return;
+    }
+    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,16 @@
       "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",
+      "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",
+      "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.6",
   "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.6"
   },
   "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.6",
+    "@nx/js": "23.1.0-beta.6"
   },
   "devDependencies": {
-    "nx": "23.1.0-beta.4"
+    "nx": "23.1.0-beta.6"
   },
   "peerDependenciesMeta": {
     "@nx/jest": {