@angular-eslint/eslint-plugin 20.0.1-alpha.5 → 20.0.1-alpha.7

package/README.md

@@ -24,6 +24,8 @@ Please see https://github.com/angular-eslint/angular-eslint for full usage instr
 | [`contextual-lifecycle`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/contextual-lifecycle.md) | Ensures that lifecycle methods are used in a correct context | :white_check_mark: |  |  |
 | [`no-async-lifecycle-method`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-async-lifecycle-method.md) | Angular Lifecycle methods should not be async. Angular does not wait for async lifecycle but the code incorrectly suggests it does. |  |  |  |
 | [`no-attribute-decorator`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-attribute-decorator.md) | The @Attribute decorator is used to obtain a single value for an attribute. This is a much less common use-case than getting a stream of values (using @Input), so often the @Attribute decorator is mistakenly used when @Input was what was intended. This rule disallows usage of @Attribute decorator altogether in order to prevent these mistakes. |  |  |  |
+| [`no-developer-preview`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-developer-preview.md) | Disallow using code which is marked as developer preview |  |  |  |
+| [`no-experimental`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-experimental.md) | Disallow using code which is marked as experimental |  |  |  |
 | [`require-lifecycle-on-prototype`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/require-lifecycle-on-prototype.md) | Ensures that lifecycle methods are defined on the object's prototype instead of on an instance. |  |  |  |
 | [`sort-lifecycle-methods`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/sort-lifecycle-methods.md) | Ensures that lifecycle methods are declared in order of execution |  |  |  |
 <!-- prettier-ignore-end -->

package/dist/configs/all.json

@@ -13,8 +13,10 @@
     "@angular-eslint/no-async-lifecycle-method": "error",
     "@angular-eslint/no-attribute-decorator": "error",
     "@angular-eslint/no-conflicting-lifecycle": "error",
+    "@angular-eslint/no-developer-preview": "error",
     "@angular-eslint/no-duplicates-in-metadata-arrays": "error",
     "@angular-eslint/no-empty-lifecycle-method": "error",
+    "@angular-eslint/no-experimental": "error",
     "@angular-eslint/no-forward-ref": "error",
     "@angular-eslint/no-input-prefix": "error",
     "@angular-eslint/no-input-rename": "error",

package/dist/index.d.ts

@@ -15,8 +15,10 @@ declare const _default: {
                 "@angular-eslint/no-async-lifecycle-method": string;
                 "@angular-eslint/no-attribute-decorator": string;
                 "@angular-eslint/no-conflicting-lifecycle": string;
+                "@angular-eslint/no-developer-preview": string;
                 "@angular-eslint/no-duplicates-in-metadata-arrays": string;
                 "@angular-eslint/no-empty-lifecycle-method": string;
+                "@angular-eslint/no-experimental": string;
                 "@angular-eslint/no-forward-ref": string;
                 "@angular-eslint/no-input-prefix": string;
                 "@angular-eslint/no-input-rename": string;
@@ -118,6 +120,8 @@ declare const _default: {
         "use-injectable-provided-in": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/use-injectable-provided-in").MessageIds, import("./rules/use-injectable-provided-in").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "use-lifecycle-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"useLifecycleInterface", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "use-pipe-transform-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"usePipeTransformInterface", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "no-experimental": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noExperimental", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "no-developer-preview": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noDeveloperPreview", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     };
 };
 export = _default;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqIA,kBAmDE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2IA,kBAqDE"}

package/dist/index.js

@@ -80,6 +80,8 @@ const use_component_view_encapsulation_1 = __importStar(require("./rules/use-com
 const use_injectable_provided_in_1 = __importStar(require("./rules/use-injectable-provided-in"));
 const use_lifecycle_interface_1 = __importStar(require("./rules/use-lifecycle-interface"));
 const use_pipe_transform_interface_1 = __importStar(require("./rules/use-pipe-transform-interface"));
+const no_experimental_1 = __importStar(require("./rules/no-experimental"));
+const no_developer_preview_1 = __importStar(require("./rules/no-developer-preview"));
 module.exports = {
     configs: {
         all: all_json_1.default,
@@ -129,5 +131,7 @@ module.exports = {
         [use_injectable_provided_in_1.RULE_NAME]: use_injectable_provided_in_1.default,
         [use_lifecycle_interface_1.RULE_NAME]: use_lifecycle_interface_1.default,
         [use_pipe_transform_interface_1.RULE_NAME]: use_pipe_transform_interface_1.default,
+        [no_experimental_1.RULE_NAME]: no_experimental_1.default,
+        [no_developer_preview_1.RULE_NAME]: no_developer_preview_1.default,
     },
 };

package/dist/rules/no-developer-preview.d.ts

@@ -0,0 +1,6 @@
+export type Options = [];
+export type MessageIds = 'noDeveloperPreview';
+export declare const RULE_NAME = "no-developer-preview";
+declare const _default: import("@typescript-eslint/utils/eslint-utils").RuleModule<"noDeveloperPreview", [], import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/eslint-utils").RuleListener>;
+export default _default;
+//# sourceMappingURL=no-developer-preview.d.ts.map

package/dist/rules/no-developer-preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-developer-preview.d.ts","sourceRoot":"","sources":["../../src/rules/no-developer-preview.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,oBAAoB,CAAC;AAC9C,eAAO,MAAM,SAAS,yBAAyB,CAAC;;AAEhD,wBAsCG"}

package/dist/rules/no-developer-preview.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const eslint_utils_1 = require("@typescript-eslint/utils/eslint-utils");
+const jsdoc_1 = require("../utils/jsdoc");
+exports.RULE_NAME = 'no-developer-preview';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: `Disallow using code which is marked as developer preview`,
+        },
+        schema: [],
+        messages: {
+            noDeveloperPreview: '`{{name}}` is in developer preview',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const services = (0, eslint_utils_1.getParserServices)(context);
+        const checker = services.program.getTypeChecker();
+        return {
+            Identifier: (node) => {
+                if ((0, jsdoc_1.isDeclaration)(node) || (0, jsdoc_1.isInsideExportOrImport)(node)) {
+                    return;
+                }
+                const symbols = (0, jsdoc_1.getSymbols)(node, services, checker);
+                if (!(0, jsdoc_1.hasJsDocTag)(symbols, 'developerPreview')) {
+                    return;
+                }
+                const { name } = node;
+                context.report({
+                    node,
+                    messageId: 'noDeveloperPreview',
+                    data: { name },
+                });
+            },
+        };
+    },
+});

package/dist/rules/no-experimental.d.ts

@@ -0,0 +1,6 @@
+export type Options = [];
+export type MessageIds = 'noExperimental';
+export declare const RULE_NAME = "no-experimental";
+declare const _default: import("@typescript-eslint/utils/eslint-utils").RuleModule<"noExperimental", [], import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/eslint-utils").RuleListener>;
+export default _default;
+//# sourceMappingURL=no-experimental.d.ts.map

package/dist/rules/no-experimental.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-experimental.d.ts","sourceRoot":"","sources":["../../src/rules/no-experimental.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,gBAAgB,CAAC;AAC1C,eAAO,MAAM,SAAS,oBAAoB,CAAC;;AAE3C,wBAsCG"}

package/dist/rules/no-experimental.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const eslint_utils_1 = require("@typescript-eslint/utils/eslint-utils");
+const jsdoc_1 = require("../utils/jsdoc");
+exports.RULE_NAME = 'no-experimental';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: `Disallow using code which is marked as experimental`,
+        },
+        schema: [],
+        messages: {
+            noExperimental: '`{{name}}` is experimental',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const services = (0, eslint_utils_1.getParserServices)(context);
+        const checker = services.program.getTypeChecker();
+        return {
+            Identifier: (node) => {
+                if ((0, jsdoc_1.isDeclaration)(node) || (0, jsdoc_1.isInsideExportOrImport)(node)) {
+                    return;
+                }
+                const symbols = (0, jsdoc_1.getSymbols)(node, services, checker);
+                if (!(0, jsdoc_1.hasJsDocTag)(symbols, 'experimental')) {
+                    return;
+                }
+                const { name } = node;
+                context.report({
+                    node,
+                    messageId: 'noExperimental',
+                    data: { name },
+                });
+            },
+        };
+    },
+});

package/dist/utils/jsdoc.d.ts

@@ -0,0 +1,11 @@
+import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/utils';
+import ts from 'typescript';
+export type CallLikeNode = TSESTree.CallExpression | TSESTree.NewExpression | TSESTree.TaggedTemplateExpression;
+export declare function getCallLikeNode(node: TSESTree.Node): CallLikeNode | undefined;
+export declare function getSymbols(node: TSESTree.Identifier, services: ParserServicesWithTypeInformation, checker: ts.TypeChecker): (ts.Symbol | undefined)[];
+export declare function isNodeCalleeOfParent(node: TSESTree.Node): node is CallLikeNode;
+export declare function hasJsDocTag(symbols: (ts.Symbol | undefined)[], tagName: string): boolean;
+export declare function getCallLikeNodeSymbol(node: CallLikeNode, services: ParserServicesWithTypeInformation, checker: ts.TypeChecker): ts.Symbol | undefined;
+export declare function isDeclaration(node: TSESTree.Identifier): boolean;
+export declare function isInsideExportOrImport(node: TSESTree.Node): boolean;
+//# sourceMappingURL=jsdoc.d.ts.map

package/dist/utils/jsdoc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsdoc.d.ts","sourceRoot":"","sources":["../../src/utils/jsdoc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iCAAiC,EACjC,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,MAAM,YAAY,CAAC;AAG5B,MAAM,MAAM,YAAY,GACpB,QAAQ,CAAC,cAAc,GACvB,QAAQ,CAAC,aAAa,GACtB,QAAQ,CAAC,wBAAwB,CAAC;AAEtC,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,YAAY,GAAG,SAAS,CAW7E;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,QAAQ,CAAC,UAAU,EACzB,QAAQ,EAAE,iCAAiC,EAC3C,OAAO,EAAE,EAAE,CAAC,WAAW,GACtB,CAAC,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAqB3B;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAClB,IAAI,IAAI,YAAY,CAYtB;AAED,wBAAgB,WAAW,CACzB,OAAO,EAAE,CAAC,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,EAClC,OAAO,EAAE,MAAM,GACd,OAAO,CAIT;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,iCAAiC,EAC3C,OAAO,EAAE,EAAE,CAAC,WAAW,GACtB,EAAE,CAAC,MAAM,GAAG,SAAS,CAMvB;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,GAAG,OAAO,CA2ChE;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CAuBnE"}

package/dist/utils/jsdoc.js

@@ -0,0 +1,174 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCallLikeNode = getCallLikeNode;
+exports.getSymbols = getSymbols;
+exports.isNodeCalleeOfParent = isNodeCalleeOfParent;
+exports.hasJsDocTag = hasJsDocTag;
+exports.getCallLikeNodeSymbol = getCallLikeNodeSymbol;
+exports.isDeclaration = isDeclaration;
+exports.isInsideExportOrImport = isInsideExportOrImport;
+const utils_1 = require("@typescript-eslint/utils");
+const typescript_1 = __importDefault(require("typescript"));
+const tsutils = __importStar(require("ts-api-utils"));
+function getCallLikeNode(node) {
+    let callee = node;
+    while (callee.parent?.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        callee.parent.property === callee) {
+        callee = callee.parent;
+    }
+    return isNodeCalleeOfParent(callee) ? callee : undefined;
+}
+function getSymbols(node, services, checker) {
+    const callLikeNode = getCallLikeNode(node);
+    if (callLikeNode) {
+        return [getCallLikeNodeSymbol(callLikeNode, services, checker)];
+    }
+    else if (node.parent.type === utils_1.AST_NODE_TYPES.Property) {
+        const property = services
+            .getTypeAtLocation(node.parent.parent)
+            .getProperty(node.name);
+        const propertySymbol = services.getSymbolAtLocation(node);
+        const valueSymbol = checker.getShorthandAssignmentValueSymbol(propertySymbol?.valueDeclaration);
+        return [
+            ...getSymbolsInAliasesChain(propertySymbol, checker),
+            property,
+            propertySymbol,
+            valueSymbol,
+        ];
+    }
+    return getSymbolsInAliasesChain(services.getSymbolAtLocation(node), checker);
+}
+function isNodeCalleeOfParent(node) {
+    switch (node.parent?.type) {
+        case utils_1.AST_NODE_TYPES.NewExpression:
+        case utils_1.AST_NODE_TYPES.CallExpression:
+            return node.parent.callee === node;
+        case utils_1.AST_NODE_TYPES.TaggedTemplateExpression:
+            return node.parent.tag === node;
+        default:
+            return false;
+    }
+}
+function hasJsDocTag(symbols, tagName) {
+    return symbols.some((symbol) => symbol?.getJsDocTags().some((tag) => tag.name === tagName));
+}
+function getCallLikeNodeSymbol(node, services, checker) {
+    const symbol = services.getSymbolAtLocation(node);
+    return symbol !== undefined &&
+        tsutils.isSymbolFlagSet(symbol, typescript_1.default.SymbolFlags.Alias)
+        ? checker.getAliasedSymbol(symbol)
+        : symbol;
+}
+function isDeclaration(node) {
+    const { parent } = node;
+    switch (parent.type) {
+        case utils_1.AST_NODE_TYPES.ClassDeclaration:
+        case utils_1.AST_NODE_TYPES.VariableDeclarator:
+        case utils_1.AST_NODE_TYPES.TSEnumMember:
+            return parent.id === node;
+        case utils_1.AST_NODE_TYPES.MethodDefinition:
+        case utils_1.AST_NODE_TYPES.PropertyDefinition:
+        case utils_1.AST_NODE_TYPES.AccessorProperty:
+            return parent.key === node;
+        case utils_1.AST_NODE_TYPES.Property:
+            if (parent.shorthand && parent.value === node) {
+                return parent.parent.type === utils_1.AST_NODE_TYPES.ObjectPattern;
+            }
+            if (parent.value === node) {
+                return false;
+            }
+            return parent.parent.type === utils_1.AST_NODE_TYPES.ObjectExpression;
+        case utils_1.AST_NODE_TYPES.AssignmentPattern:
+            return parent.left === node;
+        case utils_1.AST_NODE_TYPES.FunctionDeclaration:
+        case utils_1.AST_NODE_TYPES.FunctionExpression:
+        case utils_1.AST_NODE_TYPES.TSDeclareFunction:
+        case utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression:
+        case utils_1.AST_NODE_TYPES.TSEnumDeclaration:
+        case utils_1.AST_NODE_TYPES.TSInterfaceDeclaration:
+        case utils_1.AST_NODE_TYPES.TSMethodSignature:
+        case utils_1.AST_NODE_TYPES.TSModuleDeclaration:
+        case utils_1.AST_NODE_TYPES.TSParameterProperty:
+        case utils_1.AST_NODE_TYPES.TSPropertySignature:
+        case utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration:
+        case utils_1.AST_NODE_TYPES.TSTypeParameter:
+            return true;
+        default:
+            return false;
+    }
+}
+function isInsideExportOrImport(node) {
+    let current = node;
+    while (true) {
+        switch (current.type) {
+            case utils_1.AST_NODE_TYPES.ExportNamedDeclaration:
+            case utils_1.AST_NODE_TYPES.ImportDeclaration:
+                return true;
+            case utils_1.AST_NODE_TYPES.BlockStatement:
+            case utils_1.AST_NODE_TYPES.ClassDeclaration:
+            case utils_1.AST_NODE_TYPES.TSInterfaceDeclaration:
+            case utils_1.AST_NODE_TYPES.FunctionDeclaration:
+            case utils_1.AST_NODE_TYPES.FunctionExpression:
+            case utils_1.AST_NODE_TYPES.Program:
+            case utils_1.AST_NODE_TYPES.TSUnionType:
+            case utils_1.AST_NODE_TYPES.VariableDeclarator:
+                return false;
+            default:
+                current = current.parent;
+        }
+    }
+}
+function getSymbolsInAliasesChain(symbol, checker) {
+    const symbols = [symbol];
+    if (!symbol || !tsutils.isSymbolFlagSet(symbol, typescript_1.default.SymbolFlags.Alias)) {
+        return symbols;
+    }
+    const targetSymbol = checker.getAliasedSymbol(symbol);
+    while (tsutils.isSymbolFlagSet(symbol, typescript_1.default.SymbolFlags.Alias)) {
+        const immediateAliasedSymbol = symbol.getDeclarations() && checker.getImmediateAliasedSymbol(symbol);
+        if (!immediateAliasedSymbol) {
+            break;
+        }
+        symbol = immediateAliasedSymbol;
+        if (symbol === targetSymbol) {
+            symbols.push(symbol);
+        }
+    }
+    return symbols;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/eslint-plugin",
-  "version": "20.0.1-alpha.5",
+  "version": "20.0.1-alpha.7",
   "description": "ESLint plugin for Angular applications, following https://angular.dev/style-guide",
   "license": "MIT",
   "main": "dist/index.js",
@@ -18,11 +18,12 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@angular-eslint/bundled-angular-compiler": "20.0.1-alpha.5",
-    "@angular-eslint/utils": "20.0.1-alpha.5"
+    "ts-api-utils": "^2.1.0",
+    "@angular-eslint/bundled-angular-compiler": "20.0.1-alpha.7",
+    "@angular-eslint/utils": "20.0.1-alpha.7"
   },
   "devDependencies": {
-    "@angular-eslint/test-utils": "20.0.1-alpha.5"
+    "@angular-eslint/test-utils": "20.0.1-alpha.7"
   },
   "peerDependencies": {
     "@typescript-eslint/utils": "^7.11.0 || ^8.0.0",