@nx/eslint 23.1.0-beta.5 → 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

@@ -8,8 +8,8 @@ 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");
+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.
@@ -43,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);
     }
@@ -289,7 +292,7 @@ function processConvertedConfig(tree, root, source, target, { content, addESLint
     // 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);
+        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.
@@ -297,15 +300,3 @@ function processConvertedConfig(tree, root, source, target, { content, addESLint
     // `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/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/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),
     ];

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

@@ -7,6 +7,20 @@ config that still references it fails to load. It was split into three rules:
 - `@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'`,

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

@@ -3,10 +3,13 @@ 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.
+// 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',
@@ -14,6 +17,14 @@ const ESLINT_FLAT_CONFIG_FILENAMES = [
     '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
@@ -67,7 +78,21 @@ const RENAMED_TS_ESLINT_RULES = new Map([
         '@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();

package/migrations.json

@@ -27,17 +27,11 @@
     },
     "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"
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/eslint",
-  "version": "23.1.0-beta.5",
+  "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.5"
+    "@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.5",
-    "@nx/js": "23.1.0-beta.5"
+    "@nx/devkit": "23.1.0-beta.6",
+    "@nx/js": "23.1.0-beta.6"
   },
   "devDependencies": {
-    "nx": "23.1.0-beta.5"
+    "nx": "23.1.0-beta.6"
   },
   "peerDependenciesMeta": {
     "@nx/jest": {