@benjavicente/lint-angular 0.0.2 → 0.0.4

package/dist/index.mjs

@@ -55,13 +55,13 @@ function unwrapExpression(node) {
 }
 //#endregion
 //#region src/utilities/scope.ts
-const FUNCTION_TYPES$1 = new Set([
+const FUNCTION_TYPES$2 = new Set([
 	"ArrowFunctionExpression",
 	"FunctionDeclaration",
 	"FunctionExpression"
 ]);
 function isFunction$1(node) {
-	return !!node && FUNCTION_TYPES$1.has(node.type);
+	return !!node && FUNCTION_TYPES$2.has(node.type);
 }
 function addBindingIdentifierNodes(node, identifiers) {
 	if (!node) return;
@@ -171,19 +171,45 @@ function isShadowedIdentifier(context, node) {
 }
 //#endregion
 //#region src/utilities/angular.ts
-function addAngularCoreDecoratorImport(specifier, decoratorNames, imports) {
-	if (specifier.type === "ImportSpecifier") {
-		const importedName = getPropertyName(specifier.imported);
-		if (importedName && decoratorNames.has(importedName)) imports.decoratorLocalNames.add(specifier.local.name);
+function getProgramNode(context, node) {
+	if (node.type === "Program") return node;
+	return context.sourceCode.getAncestors(node).find((ancestor) => ancestor.type === "Program") ?? null;
+}
+function getImportedName(context, node, source) {
+	if (node?.type !== "Identifier") return null;
+	if (isShadowedIdentifier(context, node)) return null;
+	const program = getProgramNode(context, node);
+	for (const statement of program?.body ?? []) {
+		if (statement.type !== "ImportDeclaration" || statement.source?.value !== source) continue;
+		for (const specifier of statement.specifiers ?? []) {
+			if (specifier.type !== "ImportSpecifier" || specifier.local.name !== node.name) continue;
+			return getPropertyName(specifier.imported);
+		}
+	}
+	return null;
+}
+function isNamespaceImport(context, node, source) {
+	if (node?.type !== "Identifier") return false;
+	if (isShadowedIdentifier(context, node)) return false;
+	const program = getProgramNode(context, node);
+	for (const statement of program?.body ?? []) {
+		if (statement.type !== "ImportDeclaration" || statement.source?.value !== source) continue;
+		if ((statement.specifiers ?? []).some((specifier) => specifier.type === "ImportNamespaceSpecifier" && specifier.local.name === node.name)) return true;
 	}
-	if (specifier.type === "ImportNamespaceSpecifier") imports.angularNamespaces.add(specifier.local.name);
+	return false;
+}
+function isImportedReference(context, node, source, importedNames) {
+	const importedName = getImportedName(context, node, source);
+	return !!importedName && importedNames.has(importedName);
+}
+function isImportedNamespaceMember(context, node, source, memberNames) {
+	return node?.type === "MemberExpression" && node.object?.type === "Identifier" && isNamespaceImport(context, node.object, source) && memberNames.has(getPropertyName(node.property) ?? "");
 }
-function isAngularCoreDecorator(context, decorator, imports) {
+function isAngularCoreDecorator(context, decorator, decoratorNames) {
 	if (!decorator) return false;
 	const expression = decorator.expression ?? decorator;
 	const callee = expression?.type === "CallExpression" ? expression.callee : expression;
-	if (callee?.type === "Identifier") return imports.decoratorLocalNames.has(callee.name) && !isShadowedIdentifier(context, callee);
-	return callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && imports.angularNamespaces.has(callee.object.name) && !isShadowedIdentifier(context, callee.object) && imports.decoratorNames.has(getPropertyName(callee.property) ?? "");
+	return isImportedReference(context, callee, "@angular/core", decoratorNames) || isImportedNamespaceMember(context, callee, "@angular/core", decoratorNames);
 }
 //#endregion
 //#region src/rules/class-member-order/index.ts
@@ -196,7 +222,7 @@ const ANGULAR_CLASS_DECORATOR_NAMES$1 = new Set([
 ]);
 const INPUT_MODEL_CALL_NAMES = new Set(["input", "model"]);
 const OUTPUT_CALL_NAMES = new Set(["output", "outputFromObservable"]);
-const CLASS_FIELD_TYPES$1 = new Set([
+const CLASS_FIELD_TYPES$2 = new Set([
 	"AccessorProperty",
 	"FieldDefinition",
 	"PropertyDefinition"
@@ -207,38 +233,33 @@ const ORDER_LABELS = [
 	"outputs",
 	"everything else"
 ];
-function hasAngularClassDecorator(context, classNode, imports) {
+function hasAngularClassDecorator(context, classNode) {
 	if (!classNode || !Array.isArray(classNode.decorators)) return false;
-	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, imports));
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, ANGULAR_CLASS_DECORATOR_NAMES$1));
 }
-function isApiCall(context, node, localNames, angularNamespaces, apiNames) {
+function isApiCall(context, node, apiNames) {
 	if (!node || node.type !== "CallExpression") return false;
 	const callee = node.callee;
-	if (callee?.type === "Identifier") return localNames.has(callee.name) && !isShadowedIdentifier(context, callee);
+	if (isImportedReference(context, callee, "@angular/core", apiNames)) return true;
 	if (callee?.type !== "MemberExpression") return false;
 	const supportsRequiredApi = [...INPUT_MODEL_CALL_NAMES].some((name) => apiNames.has(name));
 	if (callee.object?.type === "Identifier") {
-		if (getPropertyName(callee.property) === "required") return supportsRequiredApi && localNames.has(callee.object.name) && !isShadowedIdentifier(context, callee.object);
-		return angularNamespaces.has(callee.object.name) && !isShadowedIdentifier(context, callee.object) && apiNames.has(getPropertyName(callee.property) ?? "");
+		if (getPropertyName(callee.property) === "required") return supportsRequiredApi && isImportedReference(context, callee.object, "@angular/core", apiNames);
+		return isImportedNamespaceMember(context, callee, "@angular/core", apiNames);
 	}
-	if (getPropertyName(callee.property) === "required" && callee.object?.type === "MemberExpression" && callee.object.object?.type === "Identifier") return supportsRequiredApi && angularNamespaces.has(callee.object.object.name) && !isShadowedIdentifier(context, callee.object.object) && apiNames.has(getPropertyName(callee.object.property) ?? "");
+	if (getPropertyName(callee.property) === "required" && callee.object?.type === "MemberExpression" && callee.object.object?.type === "Identifier") return supportsRequiredApi && isImportedNamespaceMember(context, callee.object, "@angular/core", apiNames) && apiNames.has(getPropertyName(callee.object.property) ?? "");
 	return false;
 }
-function hasDecorator(context, element, localNames, angularNamespaces, decoratorNames) {
-	return Array.isArray(element.decorators) ? element.decorators.some((decorator) => {
-		const expression = decorator.expression ?? decorator;
-		const callee = expression?.type === "CallExpression" ? expression.callee : expression;
-		if (callee?.type === "Identifier") return localNames.has(callee.name) && !isShadowedIdentifier(context, callee);
-		return callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && angularNamespaces.has(callee.object.name) && !isShadowedIdentifier(context, callee.object) && decoratorNames.has(getPropertyName(callee.property) ?? "");
-	}) : false;
-}
-function classifyMember(context, element, imports) {
-	if (CLASS_FIELD_TYPES$1.has(element.type)) {
-		if (isApiCall(context, element.value, imports.injectLocalNames, imports.angularNamespaces, new Set(["inject"]))) return 0;
-		if (isApiCall(context, element.value, imports.inputModelLocalNames, imports.angularNamespaces, INPUT_MODEL_CALL_NAMES)) return 1;
-		if (hasDecorator(context, element, imports.inputModelDecoratorLocalNames, imports.angularNamespaces, new Set(["Input"]))) return 1;
-		if (isApiCall(context, element.value, imports.outputLocalNames, imports.angularNamespaces, OUTPUT_CALL_NAMES)) return 2;
-		if (hasDecorator(context, element, imports.outputDecoratorLocalNames, imports.angularNamespaces, new Set(["Output"]))) return 2;
+function hasDecorator(context, element, decoratorNames) {
+	return Array.isArray(element.decorators) ? element.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, decoratorNames)) : false;
+}
+function classifyMember(context, element) {
+	if (CLASS_FIELD_TYPES$2.has(element.type)) {
+		if (isApiCall(context, element.value, new Set(["inject"]))) return 0;
+		if (isApiCall(context, element.value, INPUT_MODEL_CALL_NAMES)) return 1;
+		if (hasDecorator(context, element, new Set(["Input"]))) return 1;
+		if (isApiCall(context, element.value, OUTPUT_CALL_NAMES)) return 2;
+		if (hasDecorator(context, element, new Set(["Output"]))) return 2;
 		return 3;
 	}
 	if (element.type === "MethodDefinition") return 3;
@@ -314,7 +335,7 @@ function getSortedMembersFix(context, classBody, classifiedMembers) {
 	for (const member of classifiedMembers) if (member.name) membersByName.set(member.name, member);
 	for (const member of classifiedMembers) {
 		const { element } = member;
-		if (!CLASS_FIELD_TYPES$1.has(element.type)) return void 0;
+		if (!CLASS_FIELD_TYPES$2.has(element.type)) return void 0;
 		if (element.type === "AccessorProperty") return void 0;
 		if (element.computed) return void 0;
 		if (Array.isArray(element.decorators) && element.decorators.length > 0) return void 0;
@@ -354,83 +375,47 @@ const classMemberOrder = defineRule({
 		messages: { outOfOrder: "Angular class member should be ordered before {{previousGroup}} and with {{expectedGroup}}." }
 	},
 	createOnce(context) {
-		const imports = {
-			decoratorNames: ANGULAR_CLASS_DECORATOR_NAMES$1,
-			decoratorLocalNames: /* @__PURE__ */ new Set(),
-			injectLocalNames: /* @__PURE__ */ new Set(),
-			inputModelLocalNames: /* @__PURE__ */ new Set(),
-			inputModelDecoratorLocalNames: /* @__PURE__ */ new Set(),
-			outputLocalNames: /* @__PURE__ */ new Set(),
-			outputDecoratorLocalNames: /* @__PURE__ */ new Set(),
-			angularNamespaces: /* @__PURE__ */ new Set()
-		};
-		return {
-			before() {
-				imports.decoratorLocalNames.clear();
-				imports.injectLocalNames.clear();
-				imports.inputModelLocalNames.clear();
-				imports.inputModelDecoratorLocalNames.clear();
-				imports.outputLocalNames.clear();
-				imports.outputDecoratorLocalNames.clear();
-				imports.angularNamespaces.clear();
-			},
-			ImportDeclaration(node) {
-				if (node.source?.value !== "@angular/core") return;
-				for (const specifier of node.specifiers ?? []) {
-					addAngularCoreDecoratorImport(specifier, ANGULAR_CLASS_DECORATOR_NAMES$1, imports);
-					if (specifier.type === "ImportSpecifier") {
-						const importedName = getPropertyName(specifier.imported);
-						if (importedName === "inject") imports.injectLocalNames.add(specifier.local.name);
-						if (importedName && INPUT_MODEL_CALL_NAMES.has(importedName)) imports.inputModelLocalNames.add(specifier.local.name);
-						if (importedName === "Input") imports.inputModelDecoratorLocalNames.add(specifier.local.name);
-						if (importedName && OUTPUT_CALL_NAMES.has(importedName)) imports.outputLocalNames.add(specifier.local.name);
-						if (importedName === "Output") imports.outputDecoratorLocalNames.add(specifier.local.name);
-					}
-					if (specifier.type === "ImportNamespaceSpecifier") imports.angularNamespaces.add(specifier.local.name);
-				}
-			},
-			ClassBody(node) {
-				const classBody = node;
-				if (!hasAngularClassDecorator(context, classBody.parent, imports)) return;
-				let highestSeen = null;
-				const classifiedMembers = [];
-				const outOfOrderReports = [];
-				for (const element of classBody.body ?? []) {
-					const group = classifyMember(context, element, imports);
-					if (group === null) continue;
-					classifiedMembers.push({
+		return { ClassBody(node) {
+			const classBody = node;
+			if (!hasAngularClassDecorator(context, classBody.parent)) return;
+			let highestSeen = null;
+			const classifiedMembers = [];
+			const outOfOrderReports = [];
+			for (const element of classBody.body ?? []) {
+				const group = classifyMember(context, element);
+				if (group === null) continue;
+				classifiedMembers.push({
+					element,
+					group,
+					effectiveGroup: group,
+					name: getMemberName$1(element.key),
+					dependencies: collectThisMemberReferences(element.value)
+				});
+			}
+			applyDependencyGroups(classifiedMembers);
+			for (const { element, effectiveGroup } of classifiedMembers) {
+				if (highestSeen !== null && effectiveGroup < highestSeen) {
+					outOfOrderReports.push({
 						element,
-						group,
-						effectiveGroup: group,
-						name: getMemberName$1(element.key),
-						dependencies: collectThisMemberReferences(element.value)
+						effectiveGroup,
+						previousEffectiveGroup: highestSeen
 					});
+					continue;
 				}
-				applyDependencyGroups(classifiedMembers);
-				for (const { element, effectiveGroup } of classifiedMembers) {
-					if (highestSeen !== null && effectiveGroup < highestSeen) {
-						outOfOrderReports.push({
-							element,
-							effectiveGroup,
-							previousEffectiveGroup: highestSeen
-						});
-						continue;
-					}
-					highestSeen = effectiveGroup;
-				}
-				if (!outOfOrderReports.length) return;
-				const fix = getSortedMembersFix(context, classBody, classifiedMembers);
-				for (const [index, report] of outOfOrderReports.entries()) context.report({
-					node: report.element,
-					messageId: "outOfOrder",
-					data: {
-						expectedGroup: ORDER_LABELS[report.effectiveGroup],
-						previousGroup: ORDER_LABELS[report.previousEffectiveGroup]
-					},
-					fix: index === 0 ? fix : void 0
-				});
+				highestSeen = effectiveGroup;
 			}
-		};
+			if (!outOfOrderReports.length) return;
+			const fix = getSortedMembersFix(context, classBody, classifiedMembers);
+			for (const [index, report] of outOfOrderReports.entries()) context.report({
+				node: report.element,
+				messageId: "outOfOrder",
+				data: {
+					expectedGroup: ORDER_LABELS[report.effectiveGroup],
+					previousGroup: ORDER_LABELS[report.previousEffectiveGroup]
+				},
+				fix: index === 0 ? fix : void 0
+			});
+		} };
 	}
 });
 //#endregion
@@ -438,25 +423,22 @@ const classMemberOrder = defineRule({
 const DEFAULT_DISALLOW_INJECT_INJECTOR = true;
 const DEFAULT_DISALLOW_RUN_IN_INJECTION_CONTEXT = true;
 const RUN_IN_INJECTION_CONTEXT_NAMES = new Set(["runInInjectionContext", "runInContext"]);
-function isAngularNamespaceMember(context, node, namespaces, memberName) {
-	return node?.type === "MemberExpression" && node.object?.type === "Identifier" && namespaces.has(node.object.name) && !isShadowedIdentifier(context, node.object) && getPropertyName(node.property) === memberName;
-}
-function isInjectCall(context, callNode, injectNames, angularNamespaces) {
+const INJECT_NAMES = new Set(["inject"]);
+const INJECTOR_NAMES = new Set(["Injector"]);
+function isInjectCall(context, callNode) {
 	const callee = callNode.callee;
-	return callee?.type === "Identifier" && injectNames.has(callee.name) && !isShadowedIdentifier(context, callee) || isAngularNamespaceMember(context, callee, angularNamespaces, "inject");
+	return isImportedReference(context, callee, "@angular/core", INJECT_NAMES) || isImportedNamespaceMember(context, callee, "@angular/core", INJECT_NAMES);
 }
-function isInjectorReference(context, node, injectorNames, angularNamespaces) {
-	return node?.type === "Identifier" && injectorNames.has(node.name) && !isShadowedIdentifier(context, node) || isAngularNamespaceMember(context, node, angularNamespaces, "Injector");
+function isInjectorReference(context, node) {
+	return isImportedReference(context, node, "@angular/core", INJECTOR_NAMES) || isImportedNamespaceMember(context, node, "@angular/core", INJECTOR_NAMES);
 }
-function isDisallowedInjectInjector(context, callNode, injectNames, injectorNames, angularNamespaces) {
-	if (!isInjectCall(context, callNode, injectNames, angularNamespaces)) return false;
-	return isInjectorReference(context, callNode.arguments?.[0], injectorNames, angularNamespaces);
+function isDisallowedInjectInjector(context, callNode) {
+	if (!isInjectCall(context, callNode)) return false;
+	return isInjectorReference(context, callNode.arguments?.[0]);
 }
-function isDisallowedRunInInjectionContext(context, callNode, runInInjectionContextNames, runInContextNames, angularNamespaces) {
+function isDisallowedRunInInjectionContext(context, callNode) {
 	const callee = callNode.callee;
-	if (callee?.type === "Identifier") return (runInInjectionContextNames.has(callee.name) || runInContextNames.has(callee.name)) && !isShadowedIdentifier(context, callee);
-	if (callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && angularNamespaces.has(callee.object.name) && !isShadowedIdentifier(context, callee.object)) return RUN_IN_INJECTION_CONTEXT_NAMES.has(getPropertyName(callee.property) ?? "");
-	return false;
+	return isImportedReference(context, callee, "@angular/core", RUN_IN_INJECTION_CONTEXT_NAMES) || isImportedNamespaceMember(context, callee, "@angular/core", RUN_IN_INJECTION_CONTEXT_NAMES);
 }
 const avoidExplicitInjectionContext = defineRule({
 	meta: {
@@ -485,52 +467,25 @@ const avoidExplicitInjectionContext = defineRule({
 		}
 	},
 	createOnce(context) {
-		const injectNames = /* @__PURE__ */ new Set();
-		const injectorNames = /* @__PURE__ */ new Set();
-		const runInInjectionContextNames = /* @__PURE__ */ new Set();
-		const runInContextNames = /* @__PURE__ */ new Set();
-		const angularNamespaces = /* @__PURE__ */ new Set();
-		return {
-			before() {
-				injectNames.clear();
-				injectorNames.clear();
-				runInInjectionContextNames.clear();
-				runInContextNames.clear();
-				angularNamespaces.clear();
-			},
-			ImportDeclaration(node) {
-				if (node.source?.value !== "@angular/core") return;
-				for (const specifier of node.specifiers ?? []) {
-					if (specifier.type === "ImportSpecifier") {
-						const importedName = getPropertyName(specifier.imported);
-						if (importedName === "inject") injectNames.add(specifier.local.name);
-						if (importedName === "Injector") injectorNames.add(specifier.local.name);
-						if (importedName === "runInInjectionContext") runInInjectionContextNames.add(specifier.local.name);
-						if (importedName === "runInContext") runInContextNames.add(specifier.local.name);
-					}
-					if (specifier.type === "ImportNamespaceSpecifier") angularNamespaces.add(specifier.local.name);
-				}
-			},
-			CallExpression(node) {
-				const callNode = node;
-				const options = context.options[0] ?? {};
-				const disallowInjectInjector = options.disallowInjectInjector ?? DEFAULT_DISALLOW_INJECT_INJECTOR;
-				const disallowRunInInjectionContext = options.disallowRunInInjectionContext ?? DEFAULT_DISALLOW_RUN_IN_INJECTION_CONTEXT;
-				if (disallowInjectInjector && isDisallowedInjectInjector(context, callNode, injectNames, injectorNames, angularNamespaces)) context.report({
-					node: callNode.callee,
-					messageId: "avoidInjectInjector"
-				});
-				if (disallowRunInInjectionContext && isDisallowedRunInInjectionContext(context, callNode, runInInjectionContextNames, runInContextNames, angularNamespaces)) context.report({
-					node: callNode.callee,
-					messageId: "avoidRunInInjectionContext"
-				});
-			}
-		};
+		return { CallExpression(node) {
+			const callNode = node;
+			const options = context.options[0] ?? {};
+			const disallowInjectInjector = options.disallowInjectInjector ?? DEFAULT_DISALLOW_INJECT_INJECTOR;
+			const disallowRunInInjectionContext = options.disallowRunInInjectionContext ?? DEFAULT_DISALLOW_RUN_IN_INJECTION_CONTEXT;
+			if (disallowInjectInjector && isDisallowedInjectInjector(context, callNode)) context.report({
+				node: callNode.callee,
+				messageId: "avoidInjectInjector"
+			});
+			if (disallowRunInInjectionContext && isDisallowedRunInInjectionContext(context, callNode)) context.report({
+				node: callNode.callee,
+				messageId: "avoidRunInInjectionContext"
+			});
+		} };
 	}
 });
 //#endregion
 //#region src/rules/avoid-explicit-subscription-management/index.ts
-const TARGET_DECORATORS$2 = new Set([
+const TARGET_DECORATORS$4 = new Set([
 	"Component",
 	"Directive",
 	"Injectable"
@@ -547,9 +502,9 @@ const RXJS_SUBSCRIBABLE_NAMES = new Set([
 	"ReplaySubject",
 	"Subject"
 ]);
-function hasTargetDecorator$2(context, classNode, decoratorImports) {
+function hasTargetDecorator$4(context, classNode) {
 	if (!classNode || !Array.isArray(classNode.decorators)) return false;
-	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, decoratorImports));
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, TARGET_DECORATORS$4));
 }
 function hasSubscriptionTypeReference(context, node, subscriptionLocalNames, rxjsNamespaces) {
 	if (!node) return false;
@@ -808,11 +763,6 @@ const avoidExplicitSubscriptionManagement = defineRule({
 		const rxjsNamespaces = /* @__PURE__ */ new Set();
 		const takeUntilDestroyedLocalNames = /* @__PURE__ */ new Set();
 		const interopNamespaces = /* @__PURE__ */ new Set();
-		const decoratorImports = {
-			decoratorNames: TARGET_DECORATORS$2,
-			decoratorLocalNames: /* @__PURE__ */ new Set(),
-			angularNamespaces: /* @__PURE__ */ new Set()
-		};
 		return {
 			before() {
 				subscriptionLocalNames.clear();
@@ -820,12 +770,9 @@ const avoidExplicitSubscriptionManagement = defineRule({
 				rxjsNamespaces.clear();
 				takeUntilDestroyedLocalNames.clear();
 				interopNamespaces.clear();
-				decoratorImports.decoratorLocalNames.clear();
-				decoratorImports.angularNamespaces.clear();
 			},
 			ImportDeclaration(node) {
 				const source = node.source?.value;
-				if (source === "@angular/core") for (const specifier of node.specifiers ?? []) addAngularCoreDecoratorImport(specifier, TARGET_DECORATORS$2, decoratorImports);
 				if (source === "rxjs") for (const specifier of node.specifiers ?? []) {
 					if (specifier.type === "ImportSpecifier") {
 						const importedName = getPropertyName(specifier.imported);
@@ -846,7 +793,7 @@ const avoidExplicitSubscriptionManagement = defineRule({
 			ClassBody(node) {
 				const classBody = node;
 				const classNode = classBody.parent;
-				if (!classNode || !hasTargetDecorator$2(context, classNode, decoratorImports)) return;
+				if (!classNode || !hasTargetDecorator$4(context, classNode)) return;
 				const rxjsSubscribableReferences = collectRxjsSubscribableReferences(context, classBody, classNode, rxjsSubscribableLocalNames, rxjsNamespaces);
 				const subscriptionReferences = collectSubscriptionReferences(context, classBody, classNode, subscriptionLocalNames, rxjsNamespaces, rxjsSubscribableReferences, rxjsSubscribableLocalNames, takeUntilDestroyedLocalNames, interopNamespaces);
 				walkNode$1(classBody, classNode, (current) => {
@@ -898,22 +845,59 @@ const avoidExplicitSubscriptionManagement = defineRule({
 	}
 });
 //#endregion
+//#region src/rules/avoid-inappropriate-intimacy/index.ts
+const TARGET_DECORATORS$3 = new Set([
+	"Component",
+	"Directive",
+	"Injectable",
+	"Service"
+]);
+function getAngularClassKind(context, classNode) {
+	if (!classNode || !Array.isArray(classNode.decorators)) return null;
+	if (classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, new Set(["Component"])))) return "component";
+	if (classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, new Set(["Directive"])))) return "directive";
+	if (classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, TARGET_DECORATORS$3))) return "service";
+	return null;
+}
+const avoidInappropriateIntimacy = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow passing Angular component, directive, and service instances as function arguments.",
+			recommended: true
+		},
+		schema: [],
+		messages: { avoidThisArgument: "Avoid passing this {{kind}} instance as an argument. Pass the specific values or callbacks the callee needs." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const callNode = node;
+			const thisArguments = (callNode.arguments ?? []).filter((argument) => argument.type === "ThisExpression");
+			if (!thisArguments.length) return;
+			const kind = getAngularClassKind(context, context.sourceCode.getAncestors(callNode).findLast((ancestor) => ancestor.type === "ClassDeclaration" || ancestor.type === "ClassExpression"));
+			if (!kind) return;
+			for (const argument of thisArguments) context.report({
+				node: argument,
+				messageId: "avoidThisArgument",
+				data: { kind }
+			});
+		} };
+	}
+});
+//#endregion
 //#region src/rules/avoid-ng-modules/index.ts
 const DEFAULT_ALLOW_FOR_GROUPING = true;
 const DEFAULT_ALLOW_FOR_PROVIDING = false;
 const DEFAULT_ALLOW_FOR_ROUTING = false;
-function isNgModuleDecorator(context, node, importBindings, namespaceImportBindings) {
+function isNgModuleDecorator(context, node) {
 	if (node.type !== "Decorator") return false;
 	const expression = node.expression ?? node;
 	const callee = expression?.type === "CallExpression" ? expression.callee : expression;
-	if (callee?.type === "Identifier") {
-		const binding = importBindings.get(callee.name);
-		return !!binding && binding.source === "@angular/core" && binding.importedName === "NgModule" && !isShadowedIdentifier(context, callee);
-	}
-	return callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && namespaceImportBindings.get(callee.object.name) === "@angular/core" && !isShadowedIdentifier(context, callee.object) && getPropertyName(callee.property) === "NgModule";
+	if (callee?.type === "Identifier") return getImportedName(context, callee, "@angular/core") === "NgModule";
+	return callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && isNamespaceImport(context, callee.object, "@angular/core") && getPropertyName(callee.property) === "NgModule";
 }
-function getNgModuleMetadata(context, node, importBindings, namespaceImportBindings) {
-	if (!isNgModuleDecorator(context, node, importBindings, namespaceImportBindings)) return null;
+function getNgModuleMetadata(context, node) {
+	if (!isNgModuleDecorator(context, node)) return null;
 	const expression = node.expression;
 	if (expression?.type !== "CallExpression") return null;
 	const metadata = expression.arguments?.[0];
@@ -927,18 +911,15 @@ function getArrayElementsFromProperty(metadata, propertyName) {
 function isMemberCall(node, methodName) {
 	return node.type === "CallExpression" && getPropertyName(node.callee?.property) === methodName;
 }
-function isModuleCallFromImport(node, expectedSource, expectedModuleName, importBindings, namespaceImportBindings) {
+function isModuleCallFromImport(context, node, expectedSource, expectedModuleName) {
 	if (node.type !== "CallExpression") return false;
 	const callee = node.callee;
 	if (callee?.type !== "MemberExpression") return false;
 	const moduleRef = callee.object;
-	if (moduleRef?.type === "Identifier") {
-		const binding = importBindings.get(moduleRef.name);
-		return !!binding && binding.source === expectedSource && binding.importedName === expectedModuleName;
-	}
+	if (moduleRef?.type === "Identifier") return getImportedName(context, moduleRef, expectedSource) === expectedModuleName;
 	if (moduleRef?.type !== "MemberExpression") return false;
 	if (moduleRef.object?.type !== "Identifier") return false;
-	if (namespaceImportBindings.get(moduleRef.object.name) !== expectedSource) return false;
+	if (!isNamespaceImport(context, moduleRef.object, expectedSource)) return false;
 	return getPropertyName(moduleRef.property) === expectedModuleName;
 }
 function getNgModuleClassNode(decoratorNode) {
@@ -989,123 +970,99 @@ const avoidNgModules = defineRule({
 		}
 	},
 	createOnce(context) {
-		const importBindings = /* @__PURE__ */ new Map();
-		const namespaceImportBindings = /* @__PURE__ */ new Map();
-		return {
-			before() {
-				importBindings.clear();
-				namespaceImportBindings.clear();
-			},
-			ImportDeclaration(node) {
-				const source = node.source?.value;
-				if (typeof source !== "string") return;
-				for (const specifier of node.specifiers ?? []) {
-					if (specifier.type === "ImportSpecifier") {
-						const importedName = getPropertyName(specifier.imported);
-						if (!importedName) continue;
-						importBindings.set(specifier.local.name, {
-							source,
-							importedName
+		return { Decorator(node) {
+			const options = context.options[0] ?? {};
+			const allowForGrouping = options.allowForGrouping ?? DEFAULT_ALLOW_FOR_GROUPING;
+			const allowForProviding = options.allowForProviding ?? DEFAULT_ALLOW_FOR_PROVIDING;
+			const allowForRouting = options.allowForRouting ?? DEFAULT_ALLOW_FOR_ROUTING;
+			const metadata = getNgModuleMetadata(context, node);
+			if (!metadata) return;
+			const importsElements = getArrayElementsFromProperty(metadata, "imports");
+			const exportsElements = getArrayElementsFromProperty(metadata, "exports");
+			if (!allowForGrouping && (importsElements.length > 0 || exportsElements.length > 0)) context.report({
+				node,
+				messageId: "avoidModuleImportsExports"
+			});
+			const importCalls = importsElements.filter((element) => element.type === "CallExpression");
+			if (!allowForProviding) {
+				for (const call of importCalls) {
+					const methodName = getPropertyName(call.callee?.property);
+					if (methodName === "forRoot" && isModuleCallFromImport(context, call, "@angular/router", "RouterModule") && !allowForRouting) {
+						context.report({
+							node: call,
+							messageId: "avoidRouterForRoot"
 						});
 						continue;
 					}
-					if (specifier.type === "ImportNamespaceSpecifier") namespaceImportBindings.set(specifier.local.name, source);
-				}
-			},
-			Decorator(node) {
-				const options = context.options[0] ?? {};
-				const allowForGrouping = options.allowForGrouping ?? DEFAULT_ALLOW_FOR_GROUPING;
-				const allowForProviding = options.allowForProviding ?? DEFAULT_ALLOW_FOR_PROVIDING;
-				const allowForRouting = options.allowForRouting ?? DEFAULT_ALLOW_FOR_ROUTING;
-				const metadata = getNgModuleMetadata(context, node, importBindings, namespaceImportBindings);
-				if (!metadata) return;
-				const importsElements = getArrayElementsFromProperty(metadata, "imports");
-				const exportsElements = getArrayElementsFromProperty(metadata, "exports");
-				if (!allowForGrouping && (importsElements.length > 0 || exportsElements.length > 0)) context.report({
-					node,
-					messageId: "avoidModuleImportsExports"
-				});
-				const importCalls = importsElements.filter((element) => element.type === "CallExpression");
-				if (!allowForProviding) {
-					for (const call of importCalls) {
-						const methodName = getPropertyName(call.callee?.property);
-						if (methodName === "forRoot" && isModuleCallFromImport(call, "@angular/router", "RouterModule", importBindings, namespaceImportBindings) && !allowForRouting) {
-							context.report({
-								node: call,
-								messageId: "avoidRouterForRoot"
-							});
-							continue;
-						}
-						if (methodName === "forRoot" && isModuleCallFromImport(call, "@ngrx/store", "StoreModule", importBindings, namespaceImportBindings)) {
-							context.report({
-								node: call,
-								messageId: "avoidNgrxStoreForRoot"
-							});
-							continue;
-						}
-						if (methodName === "forRoot" && isModuleCallFromImport(call, "@ngrx/effects", "EffectsModule", importBindings, namespaceImportBindings)) {
-							context.report({
-								node: call,
-								messageId: "avoidNgrxEffectsForRoot"
-							});
-							continue;
-						}
-						if (methodName === "forFeature" && isModuleCallFromImport(call, "@ngrx/store", "StoreModule", importBindings, namespaceImportBindings)) {
-							context.report({
-								node: call,
-								messageId: "avoidNgrxStoreForFeature"
-							});
-							continue;
-						}
-						if (methodName === "forFeature" && isModuleCallFromImport(call, "@ngrx/effects", "EffectsModule", importBindings, namespaceImportBindings)) {
-							context.report({
-								node: call,
-								messageId: "avoidNgrxEffectsForFeature"
-							});
-							continue;
-						}
-						if (methodName === "instrument" && isModuleCallFromImport(call, "@ngrx/store-devtools", "StoreDevtoolsModule", importBindings, namespaceImportBindings)) {
-							context.report({
-								node: call,
-								messageId: "avoidNgrxStoreDevtoolsInstrument"
-							});
-							continue;
-						}
-						if (methodName === "forRoot" && isModuleCallFromImport(call, "@ngrx/router-store", "StoreRouterConnectingModule", importBindings, namespaceImportBindings)) {
-							context.report({
-								node: call,
-								messageId: "avoidNgrxRouterStoreForRoot"
-							});
-							continue;
-						}
-						if (methodName === "forRoot" && isModuleCallFromImport(call, "@angular/router", "RouterModule", importBindings, namespaceImportBindings) && allowForRouting) continue;
-						if (!isMemberCall(call, "forRoot")) continue;
+					if (methodName === "forRoot" && isModuleCallFromImport(context, call, "@ngrx/store", "StoreModule")) {
 						context.report({
 							node: call,
-							messageId: "avoidForRoot"
+							messageId: "avoidNgrxStoreForRoot"
 						});
+						continue;
 					}
-					const staticForRootMethod = getStaticForRootMethod(getNgModuleClassNode(node));
-					if (staticForRootMethod) context.report({
-						node: staticForRootMethod.key ?? staticForRootMethod,
-						messageId: "avoidForRoot"
-					});
-				}
-				if (!allowForRouting) for (const call of importCalls) {
-					if (!isMemberCall(call, "forChild")) continue;
-					if (!isModuleCallFromImport(call, "@angular/router", "RouterModule", importBindings, namespaceImportBindings)) continue;
+					if (methodName === "forRoot" && isModuleCallFromImport(context, call, "@ngrx/effects", "EffectsModule")) {
+						context.report({
+							node: call,
+							messageId: "avoidNgrxEffectsForRoot"
+						});
+						continue;
+					}
+					if (methodName === "forFeature" && isModuleCallFromImport(context, call, "@ngrx/store", "StoreModule")) {
+						context.report({
+							node: call,
+							messageId: "avoidNgrxStoreForFeature"
+						});
+						continue;
+					}
+					if (methodName === "forFeature" && isModuleCallFromImport(context, call, "@ngrx/effects", "EffectsModule")) {
+						context.report({
+							node: call,
+							messageId: "avoidNgrxEffectsForFeature"
+						});
+						continue;
+					}
+					if (methodName === "instrument" && isModuleCallFromImport(context, call, "@ngrx/store-devtools", "StoreDevtoolsModule")) {
+						context.report({
+							node: call,
+							messageId: "avoidNgrxStoreDevtoolsInstrument"
+						});
+						continue;
+					}
+					if (methodName === "forRoot" && isModuleCallFromImport(context, call, "@ngrx/router-store", "StoreRouterConnectingModule")) {
+						context.report({
+							node: call,
+							messageId: "avoidNgrxRouterStoreForRoot"
+						});
+						continue;
+					}
+					if (methodName === "forRoot" && isModuleCallFromImport(context, call, "@angular/router", "RouterModule") && allowForRouting) continue;
+					if (!isMemberCall(call, "forRoot")) continue;
 					context.report({
 						node: call,
-						messageId: "avoidRouterForChild"
+						messageId: "avoidForRoot"
 					});
 				}
+				const staticForRootMethod = getStaticForRootMethod(getNgModuleClassNode(node));
+				if (staticForRootMethod) context.report({
+					node: staticForRootMethod.key ?? staticForRootMethod,
+					messageId: "avoidForRoot"
+				});
 			}
-		};
+			if (!allowForRouting) for (const call of importCalls) {
+				if (!isMemberCall(call, "forChild")) continue;
+				if (!isModuleCallFromImport(context, call, "@angular/router", "RouterModule")) continue;
+				context.report({
+					node: call,
+					messageId: "avoidRouterForChild"
+				});
+			}
+		} };
 	}
 });
 //#endregion
 //#region src/rules/avoid-rxjs-state-in-component/index.ts
-const TARGET_DECORATORS$1 = new Set(["Component", "Directive"]);
+const TARGET_DECORATORS$2 = new Set(["Component", "Directive"]);
 const SUBJECT_NAMES = new Set([
 	"BehaviorSubject",
 	"ReplaySubject",
@@ -1116,37 +1073,31 @@ const FIELD_NODE_TYPES$1 = new Set([
 	"FieldDefinition",
 	"PropertyDefinition"
 ]);
-function hasTargetDecorator$1(context, classNode, decoratorImports) {
+function hasTargetDecorator$3(context, classNode) {
 	if (!classNode || !Array.isArray(classNode.decorators)) return false;
-	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, decoratorImports));
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, TARGET_DECORATORS$2));
 }
-function getImportedSubjectKind(localName, subjectLocalNames) {
-	return subjectLocalNames.get(localName) ?? null;
+function getImportedSubjectKind(context, node) {
+	const importedName = getImportedName(context, node, "rxjs");
+	return SUBJECT_NAMES.has(importedName) ? importedName : null;
 }
-function getSubjectKindFromType(context, node, subjectLocalNames, rxjsNamespaces) {
+function getSubjectKindFromType(context, node) {
 	if (!node) return null;
 	if (node.type !== "TSTypeReference") return null;
-	const typeName = getTypeName(node.typeName);
-	if (!typeName) return null;
-	const localKind = getImportedSubjectKind(typeName, subjectLocalNames);
-	if (localKind && node.typeName?.type === "Identifier" && !isShadowedIdentifier(context, node.typeName)) return localKind;
-	if (!typeName.includes(".")) return null;
-	const [namespaceName, memberName] = typeName.split(".");
-	if (!rxjsNamespaces.has(namespaceName)) return null;
-	if (node.typeName?.type === "TSQualifiedName" && node.typeName.left?.type === "Identifier" && isShadowedIdentifier(context, node.typeName.left)) return null;
-	return SUBJECT_NAMES.has(memberName) ? memberName : null;
+	if (node.typeName?.type === "Identifier") return getImportedSubjectKind(context, node.typeName);
+	if (node.typeName?.type === "TSQualifiedName" && node.typeName.left?.type === "Identifier") {
+		const memberName = getPropertyName(node.typeName.right);
+		return isNamespaceImport(context, node.typeName.left, "rxjs") && SUBJECT_NAMES.has(memberName) ? memberName : null;
+	}
+	return null;
 }
-function getSubjectKindFromConstructor(context, node, subjectLocalNames, rxjsNamespaces) {
+function getSubjectKindFromConstructor(context, node) {
 	const expression = unwrapExpression(node);
 	if (expression?.type !== "NewExpression") return null;
 	const callee = unwrapExpression(expression.callee);
-	if (callee?.type === "Identifier") {
-		if (isShadowedIdentifier(context, callee)) return null;
-		return getImportedSubjectKind(callee.name, subjectLocalNames);
-	}
+	if (callee?.type === "Identifier") return getImportedSubjectKind(context, callee);
 	if (callee?.type !== "MemberExpression") return null;
-	if (callee.object?.type !== "Identifier" || !rxjsNamespaces.has(callee.object.name)) return null;
-	if (isShadowedIdentifier(context, callee.object)) return null;
+	if (callee.object?.type !== "Identifier" || !isNamespaceImport(context, callee.object, "rxjs")) return null;
 	const memberName = getPropertyName(callee.property);
 	return SUBJECT_NAMES.has(memberName) ? memberName : null;
 }
@@ -1205,14 +1156,14 @@ function getUsage(usages, fieldName) {
 	usages.set(fieldName, next);
 	return next;
 }
-function collectSubjectFields(context, classBody, subjectLocalNames, rxjsNamespaces) {
+function collectSubjectFields(context, classBody) {
 	const fields = /* @__PURE__ */ new Map();
 	for (const member of classBody.body ?? []) {
 		if (!FIELD_NODE_TYPES$1.has(member.type)) continue;
 		const fieldName = getMemberName(member.key);
 		if (!fieldName) continue;
 		const typeNode = member.typeAnnotation?.typeAnnotation;
-		const kind = getSubjectKindFromConstructor(context, member.value, subjectLocalNames, rxjsNamespaces) ?? getSubjectKindFromType(context, typeNode, subjectLocalNames, rxjsNamespaces);
+		const kind = getSubjectKindFromConstructor(context, member.value) ?? getSubjectKindFromType(context, typeNode);
 		if (!kind) continue;
 		fields.set(fieldName, {
 			key: member.key ?? member,
@@ -1260,58 +1211,28 @@ const avoidRxjsStateInComponent = defineRule({
 		}
 	},
 	createOnce(context) {
-		const subjectLocalNames = /* @__PURE__ */ new Map();
-		const rxjsNamespaces = /* @__PURE__ */ new Set();
-		const decoratorImports = {
-			decoratorNames: TARGET_DECORATORS$1,
-			decoratorLocalNames: /* @__PURE__ */ new Set(),
-			angularNamespaces: /* @__PURE__ */ new Set()
-		};
-		return {
-			before() {
-				subjectLocalNames.clear();
-				rxjsNamespaces.clear();
-				decoratorImports.decoratorLocalNames.clear();
-				decoratorImports.angularNamespaces.clear();
-			},
-			ImportDeclaration(node) {
-				if (node.source?.value === "@angular/core") {
-					for (const specifier of node.specifiers ?? []) addAngularCoreDecoratorImport(specifier, TARGET_DECORATORS$1, decoratorImports);
-					return;
-				}
-				if (node.source?.value !== "rxjs") return;
-				for (const specifier of node.specifiers ?? []) {
-					if (specifier.type === "ImportSpecifier") {
-						const importedName = getPropertyName(specifier.imported);
-						if (SUBJECT_NAMES.has(importedName)) subjectLocalNames.set(specifier.local.name, importedName);
-						continue;
-					}
-					if (specifier.type === "ImportNamespaceSpecifier") rxjsNamespaces.add(specifier.local.name);
-				}
-			},
-			ClassBody(node) {
-				const classBody = node;
-				const classNode = classBody.parent;
-				if (!hasTargetDecorator$1(context, classNode, decoratorImports)) return;
-				const fields = collectSubjectFields(context, classBody, subjectLocalNames, rxjsNamespaces);
-				const usages = collectFieldUsages(classBody, fields);
-				for (const [fieldName, field] of fields) {
-					const usage = usages.get(fieldName);
-					if (field.kind === "Subject" && isDestroySubjectUsage(usage)) {
-						context.report({
-							node: field.key,
-							messageId: "avoidDestroySubject"
-						});
-						continue;
-					}
+		return { ClassBody(node) {
+			const classBody = node;
+			const classNode = classBody.parent;
+			if (!hasTargetDecorator$3(context, classNode)) return;
+			const fields = collectSubjectFields(context, classBody);
+			const usages = collectFieldUsages(classBody, fields);
+			for (const [fieldName, field] of fields) {
+				const usage = usages.get(fieldName);
+				if (field.kind === "Subject" && isDestroySubjectUsage(usage)) {
 					context.report({
 						node: field.key,
-						messageId: "avoidRxjsState",
-						data: { kind: field.kind }
+						messageId: "avoidDestroySubject"
 					});
+					continue;
 				}
+				context.report({
+					node: field.key,
+					messageId: "avoidRxjsState",
+					data: { kind: field.kind }
+				});
 			}
-		};
+		} };
 	}
 });
 //#endregion
@@ -1328,22 +1249,21 @@ const KNOWN_SIGNAL_CREATION_FUNCTIONS = new Set([
 ]);
 const LINKED_SIGNAL_CREATOR_NAME = "linkedSignal";
 const COMPUTED_CREATOR_NAME = "computed";
-const EFFECT_CREATOR_NAME = "effect";
-function isAngularCoreNamespaceMember(context, node, angularNamespaces, memberName) {
-	return node?.type === "MemberExpression" && node.object?.type === "Identifier" && angularNamespaces.has(node.object.name) && !isShadowedIdentifier(context, node.object) && getPropertyName(node.property) === memberName;
-}
-function isSignalCreatorCall(context, node, signalCreatorNames, angularNamespaces) {
+const EFFECT_CREATOR_NAMES = new Set(["effect"]);
+const COMPUTED_CREATOR_NAMES = new Set([COMPUTED_CREATOR_NAME]);
+const LINKED_SIGNAL_CREATOR_NAMES = new Set([LINKED_SIGNAL_CREATOR_NAME]);
+function isSignalCreatorCall(context, node) {
 	if (node?.type !== "CallExpression") return false;
 	const callee = node.callee;
-	return callee?.type === "Identifier" && signalCreatorNames.has(callee.name) && !isShadowedIdentifier(context, callee) || [...KNOWN_SIGNAL_CREATION_FUNCTIONS].some((name) => isAngularCoreNamespaceMember(context, callee, angularNamespaces, name));
+	return isImportedReference(context, callee, "@angular/core", KNOWN_SIGNAL_CREATION_FUNCTIONS) || isImportedNamespaceMember(context, callee, "@angular/core", KNOWN_SIGNAL_CREATION_FUNCTIONS);
 }
-function isEffectCall(context, node, effectNames, angularNamespaces) {
+function isEffectCall(context, node) {
 	const callee = node.callee;
-	return callee?.type === "Identifier" && effectNames.has(callee.name) && !isShadowedIdentifier(context, callee) || isAngularCoreNamespaceMember(context, callee, angularNamespaces, "effect");
+	return isImportedReference(context, callee, "@angular/core", EFFECT_CREATOR_NAMES) || isImportedNamespaceMember(context, callee, "@angular/core", EFFECT_CREATOR_NAMES);
 }
-function isReactiveCreatorCall(context, node, creatorNames, angularNamespaces, angularMemberName) {
+function isReactiveCreatorCall(context, node, creatorNames) {
 	const callee = node.callee;
-	return callee?.type === "Identifier" && creatorNames.has(callee.name) && !isShadowedIdentifier(context, callee) || isAngularCoreNamespaceMember(context, callee, angularNamespaces, angularMemberName);
+	return isImportedReference(context, callee, "@angular/core", creatorNames) || isImportedNamespaceMember(context, callee, "@angular/core", creatorNames);
 }
 function isKnownSignalObject(context, objectNode, signalVariableBindings, classSignalProperties) {
 	if (!objectNode) return false;
@@ -1398,40 +1318,17 @@ const avoidWritingSignalsInReactiveContext = defineRule({
 		messages: { avoidSignalWriteInReactiveContext: "Avoid setting signal values inside {{contextName}}; move writes outside reactive derivations and effects." }
 	},
 	createOnce(context) {
-		const effectNames = /* @__PURE__ */ new Set();
-		const computedNames = /* @__PURE__ */ new Set();
-		const linkedSignalNames = /* @__PURE__ */ new Set();
-		const signalCreatorNames = /* @__PURE__ */ new Set();
-		const angularNamespaces = /* @__PURE__ */ new Set();
 		const signalVariableBindings = /* @__PURE__ */ new Map();
 		const classSignalProperties = /* @__PURE__ */ new Set();
 		return {
 			before() {
-				effectNames.clear();
-				computedNames.clear();
-				linkedSignalNames.clear();
-				signalCreatorNames.clear();
-				angularNamespaces.clear();
 				signalVariableBindings.clear();
 				classSignalProperties.clear();
 			},
-			ImportDeclaration(node) {
-				if (node.source?.value !== "@angular/core") return;
-				for (const specifier of node.specifiers ?? []) {
-					if (specifier.type === "ImportSpecifier") {
-						const importedName = getPropertyName(specifier.imported);
-						if (importedName === EFFECT_CREATOR_NAME) effectNames.add(specifier.local.name);
-						if (importedName === COMPUTED_CREATOR_NAME) computedNames.add(specifier.local.name);
-						if (importedName === LINKED_SIGNAL_CREATOR_NAME) linkedSignalNames.add(specifier.local.name);
-						if (importedName && KNOWN_SIGNAL_CREATION_FUNCTIONS.has(importedName)) signalCreatorNames.add(specifier.local.name);
-					}
-					if (specifier.type === "ImportNamespaceSpecifier") angularNamespaces.add(specifier.local.name);
-				}
-			},
 			VariableDeclarator(node) {
 				const declarator = node;
 				if (declarator.id?.type !== "Identifier") return;
-				if (!isSignalCreatorCall(context, declarator.init, signalCreatorNames, angularNamespaces)) return;
+				if (!isSignalCreatorCall(context, declarator.init)) return;
 				const bindings = signalVariableBindings.get(declarator.id.name) ?? /* @__PURE__ */ new Set();
 				bindings.add(declarator.id);
 				signalVariableBindings.set(declarator.id.name, bindings);
@@ -1439,7 +1336,7 @@ const avoidWritingSignalsInReactiveContext = defineRule({
 			"PropertyDefinition, FieldDefinition, AccessorProperty"(node) {
 				const property = node;
 				if (property.key?.type !== "Identifier") return;
-				if (!isSignalCreatorCall(context, property.value, signalCreatorNames, angularNamespaces)) return;
+				if (!isSignalCreatorCall(context, property.value)) return;
 				classSignalProperties.add(property.key.name);
 			},
 			CallExpression(node) {
@@ -1448,21 +1345,21 @@ const avoidWritingSignalsInReactiveContext = defineRule({
 				const allowComputedAndLinkedSignals = options.allowComputedAndLinkedSignals ?? false;
 				const callNode = node;
 				const callbackCandidates = [];
-				if (!allowEffects && isEffectCall(context, callNode, effectNames, angularNamespaces)) {
+				if (!allowEffects && isEffectCall(context, callNode)) {
 					const callback = callNode.arguments?.[0];
 					if (callback?.type === "ArrowFunctionExpression" || callback?.type === "FunctionExpression") callbackCandidates.push({
 						callback,
 						contextName: "effect()"
 					});
 				}
-				if (!allowComputedAndLinkedSignals && isReactiveCreatorCall(context, callNode, computedNames, angularNamespaces, COMPUTED_CREATOR_NAME)) {
+				if (!allowComputedAndLinkedSignals && isReactiveCreatorCall(context, callNode, COMPUTED_CREATOR_NAMES)) {
 					const callback = callNode.arguments?.[0];
 					if (callback?.type === "ArrowFunctionExpression" || callback?.type === "FunctionExpression") callbackCandidates.push({
 						callback,
 						contextName: "computed()"
 					});
 				}
-				if (!allowComputedAndLinkedSignals && isReactiveCreatorCall(context, callNode, linkedSignalNames, angularNamespaces, LINKED_SIGNAL_CREATOR_NAME)) for (const argumentNode of callNode.arguments ?? []) {
+				if (!allowComputedAndLinkedSignals && isReactiveCreatorCall(context, callNode, LINKED_SIGNAL_CREATOR_NAMES)) for (const argumentNode of callNode.arguments ?? []) {
 					const argument = argumentNode;
 					if (argument.type === "ArrowFunctionExpression" || argument.type === "FunctionExpression") {
 						callbackCandidates.push({
@@ -1498,11 +1395,6 @@ const avoidWritingSignalsInReactiveContext = defineRule({
 				}, true);
 			},
 			after() {
-				effectNames.clear();
-				computedNames.clear();
-				linkedSignalNames.clear();
-				signalCreatorNames.clear();
-				angularNamespaces.clear();
 				signalVariableBindings.clear();
 				classSignalProperties.clear();
 			}
@@ -1510,64 +1402,145 @@ const avoidWritingSignalsInReactiveContext = defineRule({
 	}
 });
 //#endregion
-//#region src/rules/component-class-matches-filename/index.ts
-const COMPONENT_DECORATORS$1 = new Set(["Component"]);
+//#region src/rules/class-matches-filename/index.ts
+const CLASS_FILENAME_MATCHERS = [
+	{
+		pattern: /^(.*)\.component\.ts$/u,
+		decoratorNames: ["Component"]
+	},
+	{
+		pattern: /^(.*)\.directive\.ts$/u,
+		decoratorNames: ["Directive"]
+	},
+	{
+		pattern: /^(.*)\.service\.ts$/u,
+		decoratorNames: ["Service", "Injectable"]
+	}
+];
 function toPascalCase(raw) {
 	return raw.split(/[-_\s.]+/u).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
 }
-function getExpectedComponentClassName(filename) {
+function getClassKind(suffix) {
+	return suffix.toLowerCase();
+}
+function getExpectedClassNames(filename, ignoreClassSuffix) {
 	const base = filename.split(/[/\\]/u).at(-1) ?? "";
-	const match = /^(.*)\.component\.ts$/u.exec(base);
-	if (!match) return null;
-	const stem = match[1];
-	const pascal = toPascalCase(stem);
-	return pascal ? `${pascal}Component` : null;
+	for (const { decoratorNames, pattern } of CLASS_FILENAME_MATCHERS) {
+		const match = pattern.exec(base);
+		if (!match) continue;
+		const stem = match[1];
+		const pascal = toPascalCase(stem);
+		if (!pascal) return null;
+		const suffix = decoratorNames[0];
+		return ignoreClassSuffix ? [`${pascal}${suffix}`, pascal] : [`${pascal}${suffix}`];
+	}
+	return null;
+}
+function getFileMatcher(filename) {
+	const base = filename.split(/[/\\]/u).at(-1) ?? "";
+	return CLASS_FILENAME_MATCHERS.find(({ pattern }) => pattern.test(base)) ?? null;
+}
+function getIgnoreClassSuffixOption(options, kind) {
+	const ignoreClassSuffix = options.ignoreClassSuffix ?? false;
+	if (typeof ignoreClassSuffix === "boolean") return ignoreClassSuffix;
+	return ignoreClassSuffix[kind] ?? false;
+}
+function getFileKind(matcher) {
+	return getClassKind(matcher.decoratorNames[0]);
 }
-const componentClassMatchesFilename = defineRule({
+function formatExpectedNames(expectedNames) {
+	return expectedNames.join("' or '");
+}
+function getNodeName(node) {
+	return node.id?.name ?? null;
+}
+function getBaseFilename$1(filename) {
+	return filename.split(/[/\\]/u).at(-1) ?? filename;
+}
+function hasTargetDecorator$2(context, classNode, decoratorNames) {
+	if (!Array.isArray(classNode.decorators)) return false;
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, decoratorNames));
+}
+function getDecoratedClassCountDescription(count) {
+	return count === 0 ? "no decorated classes" : `${count} decorated classes`;
+}
+const classMatchesFilename = defineRule({
 	meta: {
 		type: "suggestion",
 		docs: {
-			description: "Require the component class name to match its *.component.ts filename.",
+			description: "Require Angular component, directive, and service class names to match their filenames.",
 			recommended: true
 		},
-		schema: [],
-		messages: { classNameMismatch: "Component class name should be '{{expectedName}}' to match the filename '{{filename}}'." }
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: { ignoreClassSuffix: {
+				anyOf: [{ type: "boolean" }, {
+					type: "object",
+					additionalProperties: false,
+					properties: {
+						component: { type: "boolean" },
+						directive: { type: "boolean" },
+						service: { type: "boolean" }
+					}
+				}],
+				default: false
+			} }
+		}],
+		messages: {
+			classNameMismatch: "Angular class name should be '{{expectedName}}' to match the filename '{{filename}}'.",
+			decoratedClassCount: "Angular filename '{{filename}}' should contain exactly one matching decorated class, but found {{actual}}."
+		}
 	},
 	createOnce(context) {
-		const componentClasses = [];
-		const decoratorImports = {
-			decoratorNames: COMPONENT_DECORATORS$1,
-			decoratorLocalNames: /* @__PURE__ */ new Set(),
-			angularNamespaces: /* @__PURE__ */ new Set()
-		};
+		let programNode = null;
+		let fileMatcher = null;
+		let fileDecoratorNames = /* @__PURE__ */ new Set();
+		const decoratedClasses = [];
 		return {
 			before() {
-				componentClasses.length = 0;
-				decoratorImports.decoratorLocalNames.clear();
-				decoratorImports.angularNamespaces.clear();
+				programNode = null;
+				decoratedClasses.length = 0;
+				fileMatcher = getFileMatcher(context.filename ?? "");
+				if (!fileMatcher) return false;
+				fileDecoratorNames = new Set(fileMatcher.decoratorNames);
 			},
-			ImportDeclaration(node) {
-				if (node.source?.value !== "@angular/core") return;
-				for (const specifier of node.specifiers ?? []) addAngularCoreDecoratorImport(specifier, COMPONENT_DECORATORS$1, decoratorImports);
+			Program(node) {
+				programNode = node;
 			},
 			ClassDeclaration(node) {
+				if (!fileMatcher) return;
 				const classNode = node;
-				if (!Array.isArray(classNode.decorators)) return;
-				if (classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, decoratorImports))) componentClasses.push(classNode);
+				if (hasTargetDecorator$2(context, classNode, fileDecoratorNames)) decoratedClasses.push(classNode);
 			},
 			after() {
 				const filename = context.filename ?? "";
-				const expectedName = getExpectedComponentClassName(filename);
-				if (!expectedName) return;
-				const baseFilename = filename.split(/[/\\]/u).at(-1) ?? filename;
-				const classNode = componentClasses.find((candidate) => candidate.parent?.type === "ExportNamedDeclaration" || candidate.parent?.type === "ExportDefaultDeclaration") ?? null ?? componentClasses[0];
-				if (!classNode?.id?.name) return;
-				if (classNode.id.name === expectedName) return;
+				if (!fileMatcher) return;
+				const baseFilename = getBaseFilename$1(filename);
+				if (decoratedClasses.length !== 1) {
+					const reportNode = decoratedClasses[0]?.id ?? decoratedClasses[0] ?? programNode;
+					if (!reportNode) return;
+					context.report({
+						node: reportNode,
+						messageId: "decoratedClassCount",
+						data: {
+							actual: getDecoratedClassCountDescription(decoratedClasses.length),
+							filename: baseFilename
+						}
+					});
+					return;
+				}
+				const expectedNames = getExpectedClassNames(filename, getIgnoreClassSuffixOption(context.options[0] ?? {}, getFileKind(fileMatcher)));
+				if (!expectedNames) return;
+				const classNode = decoratedClasses[0];
+				const className = getNodeName(classNode);
+				if (!className) return;
+				if (expectedNames.includes(className)) return;
 				context.report({
 					node: classNode.id,
 					messageId: "classNameMismatch",
 					data: {
-						expectedName,
+						expectedName: formatExpectedNames(expectedNames),
 						filename: baseFilename
 					}
 				});
@@ -1577,7 +1550,7 @@ const componentClassMatchesFilename = defineRule({
 });
 //#endregion
 //#region src/rules/component-resource-filenames/index.ts
-const COMPONENT_DECORATORS = new Set(["Component"]);
+const COMPONENT_DECORATORS$1 = new Set(["Component"]);
 const STYLE_EXTENSIONS = new Set([
 	"css",
 	"less",
@@ -1609,9 +1582,9 @@ function getStaticString(node) {
 	if (node.type === "TemplateLiteral" && node.expressions?.length === 0) return { value: node.quasis?.[0]?.value?.cooked ?? node.quasis?.[0]?.value?.raw ?? "" };
 	return null;
 }
-function getComponentMetadata(context, node, decoratorImports) {
+function getComponentMetadata(context, node) {
 	if (node.type !== "Decorator") return null;
-	if (!isAngularCoreDecorator(context, node, decoratorImports)) return null;
+	if (!isAngularCoreDecorator(context, node, COMPONENT_DECORATORS$1)) return null;
 	const expression = node.expression;
 	if (expression?.type !== "CallExpression") return null;
 	const metadata = expression.arguments?.[0];
@@ -1632,13 +1605,8 @@ const componentResourceFilenames = defineRule({
 		}
 	},
 	createOnce(context) {
-		const decoratorImports = {
-			decoratorNames: COMPONENT_DECORATORS,
-			decoratorLocalNames: /* @__PURE__ */ new Set(),
-			angularNamespaces: /* @__PURE__ */ new Set()
-		};
+		let expectedStem = null;
 		function reportTemplateUrl(valueNode) {
-			const expectedStem = getExpectedStem(context.filename ?? "");
 			if (!expectedStem) return;
 			const staticString = getStaticString(valueNode);
 			if (!staticString) return;
@@ -1651,7 +1619,6 @@ const componentResourceFilenames = defineRule({
 			});
 		}
 		function reportStyleUrl(valueNode) {
-			const expectedStem = getExpectedStem(context.filename ?? "");
 			if (!expectedStem) return;
 			const staticString = getStaticString(valueNode);
 			if (!staticString) return;
@@ -1673,15 +1640,11 @@ const componentResourceFilenames = defineRule({
 		}
 		return {
 			before() {
-				decoratorImports.decoratorLocalNames.clear();
-				decoratorImports.angularNamespaces.clear();
-			},
-			ImportDeclaration(node) {
-				if (node.source?.value !== "@angular/core") return;
-				for (const specifier of node.specifiers ?? []) addAngularCoreDecoratorImport(specifier, COMPONENT_DECORATORS, decoratorImports);
+				expectedStem = getExpectedStem(context.filename ?? "");
+				if (!expectedStem) return false;
 			},
 			Decorator(node) {
-				const metadata = getComponentMetadata(context, node, decoratorImports);
+				const metadata = getComponentMetadata(context, node);
 				if (!metadata) return;
 				for (const property of metadata.properties ?? []) {
 					if (property.type !== "Property" || property.computed) continue;
@@ -1700,34 +1663,286 @@ const componentResourceFilenames = defineRule({
 	}
 });
 //#endregion
+//#region src/rules/decorator-filename-suffix/index.ts
+const FILENAME_SUFFIX_CONVENTIONS = [
+	{
+		kind: "component",
+		suffix: ".component.ts",
+		decoratorNames: new Set(["Component"])
+	},
+	{
+		kind: "directive",
+		suffix: ".directive.ts",
+		decoratorNames: new Set(["Directive"])
+	},
+	{
+		kind: "service",
+		suffix: ".service.ts",
+		decoratorNames: new Set(["Service", "Injectable"])
+	}
+];
+function getBaseFilename(filename) {
+	return filename.split(/[/\\]/u).at(-1) ?? filename;
+}
+function isTypeScriptFile(filename) {
+	return getBaseFilename(filename).endsWith(".ts");
+}
+function getMatchingConvention(context, decorator) {
+	return FILENAME_SUFFIX_CONVENTIONS.find((convention) => isAngularCoreDecorator(context, decorator, convention.decoratorNames)) ?? null;
+}
+const decoratorFilenameSuffix = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Require Angular component, directive, and service decorators to be declared in files with matching suffixes.",
+			recommended: true
+		},
+		schema: [],
+		messages: { filenameSuffix: "Angular {{kind}} decorator should be declared in a file ending with '{{suffix}}'." }
+	},
+	createOnce(context) {
+		return {
+			before() {
+				if (!isTypeScriptFile(context.filename ?? "")) return false;
+			},
+			Decorator(node) {
+				const convention = getMatchingConvention(context, node);
+				if (!convention) return;
+				if (getBaseFilename(context.filename ?? "").endsWith(convention.suffix)) return;
+				context.report({
+					node,
+					messageId: "filenameSuffix",
+					data: {
+						kind: convention.kind,
+						suffix: convention.suffix
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/injects-tanstack-query-only-in-component-body/index.ts
+const TARGET_DECORATORS$1 = new Set(["Component", "Directive"]);
+const TANSTACK_QUERY_APIS = new Set(["injectQuery", "injectMutation"]);
+const TANSTACK_QUERY_SOURCES = new Set(["@tanstack/angular-query", "@benjavicente/angular-query"]);
+const CLASS_FIELD_TYPES$1 = new Set([
+	"AccessorProperty",
+	"FieldDefinition",
+	"PropertyDefinition"
+]);
+const FUNCTION_TYPES$1 = new Set([
+	"ArrowFunctionExpression",
+	"FunctionDeclaration",
+	"FunctionExpression"
+]);
+function hasTargetDecorator$1(context, classNode) {
+	if (!classNode || !Array.isArray(classNode.decorators)) return false;
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, TARGET_DECORATORS$1));
+}
+function isTanstackQueryInjectCall(context, callNode) {
+	return [...TANSTACK_QUERY_SOURCES].some((source) => isImportedReference(context, callNode.callee, source, TANSTACK_QUERY_APIS));
+}
+function isDirectComponentOrDirectiveFieldInitializer(context, callNode) {
+	const ancestors = context.sourceCode.getAncestors(callNode);
+	const classField = ancestors.findLast((ancestor) => CLASS_FIELD_TYPES$1.has(ancestor.type));
+	if (!classField || unwrapExpression(classField.value) !== callNode) return false;
+	const classBodyIndex = ancestors.findLastIndex((ancestor) => ancestor.type === "ClassBody");
+	if (classBodyIndex === -1) return false;
+	const classBody = ancestors[classBodyIndex];
+	if (ancestors.slice(classBodyIndex + 1).some((ancestor) => FUNCTION_TYPES$1.has(ancestor.type))) return false;
+	return hasTargetDecorator$1(context, classBody?.parent);
+}
+const injectsTanstackQueryOnlyInComponentBody = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Require Angular TanStack Query injectQuery/injectMutation calls to be direct component/directive class fields.",
+			recommended: true
+		},
+		schema: [],
+		messages: { onlyInComponentBody: "Call {{name}} only as a direct class field initializer in an Angular component or directive." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const callNode = node;
+			if (!isTanstackQueryInjectCall(context, callNode)) return;
+			if (isDirectComponentOrDirectiveFieldInitializer(context, callNode)) return;
+			context.report({
+				node: callNode.callee ?? callNode,
+				messageId: "onlyInComponentBody",
+				data: { name: callNode.callee?.name ?? "this TanStack Query inject API" }
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-resource-api/index.ts
+const RESOURCE_APIS = new Set(["resource"]);
+const RXJS_RESOURCE_APIS = new Set(["rxResource"]);
+const HTTP_RESOURCE_APIS = new Set(["httpResource"]);
+function isResourceApiCall(context, callNode) {
+	const callee = callNode.callee;
+	if (isImportedReference(context, callee, "@angular/core", RESOURCE_APIS)) return true;
+	if (isImportedNamespaceMember(context, callee, "@angular/core", RESOURCE_APIS)) return true;
+	if (isImportedReference(context, callee, "@angular/core/rxjs-interop", RXJS_RESOURCE_APIS)) return true;
+	if (isImportedNamespaceMember(context, callee, "@angular/core/rxjs-interop", RXJS_RESOURCE_APIS)) return true;
+	if (isImportedReference(context, callee, "@angular/common/http", HTTP_RESOURCE_APIS)) return true;
+	if (isImportedNamespaceMember(context, callee, "@angular/common/http", HTTP_RESOURCE_APIS)) return true;
+	if (callee?.type === "MemberExpression" && callee.object?.type === "MemberExpression" && callee.object.object?.type === "Identifier" && isNamespaceImport(context, callee.object.object, "@angular/common/http") && HTTP_RESOURCE_APIS.has(getPropertyName(callee.object.property) ?? "")) return true;
+	return callee?.type === "MemberExpression" && isImportedReference(context, callee.object, "@angular/common/http", HTTP_RESOURCE_APIS);
+}
+const noResourceApi = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow Angular resource APIs in favor of a dedicated server-state library.",
+			recommended: true
+		},
+		schema: [],
+		messages: { noResourceApi: "Avoid Angular resource APIs for server state. Prefer a dedicated server-state helper such as TanStack Query." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const callNode = node;
+			if (!isResourceApiCall(context, callNode)) return;
+			context.report({
+				node: callNode.callee ?? callNode,
+				messageId: "noResourceApi"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-route-resolvers/index.ts
+const ROUTE_TYPE_NAMES$1 = new Set(["Route"]);
+const ROUTES_TYPE_NAMES$1 = new Set(["Routes"]);
+function isImportedTypeName$1(context, typeNode, importedNames) {
+	if (typeNode?.type === "Identifier") {
+		const importedName = getImportedName(context, typeNode, "@angular/router");
+		return !!importedName && importedNames.has(importedName);
+	}
+	return typeNode?.type === "TSQualifiedName" && typeNode.left?.type === "Identifier" && isNamespaceImport(context, typeNode.left, "@angular/router") && importedNames.has(getPropertyName(typeNode.right) ?? "");
+}
+function getTypeParameterNodes$1(typeNode) {
+	return typeNode.typeParameters?.params ?? typeNode.typeArguments?.params ?? [];
+}
+function isRouteType$1(context, typeNode) {
+	return typeNode?.type === "TSTypeReference" && isImportedTypeName$1(context, typeNode.typeName, ROUTE_TYPE_NAMES$1);
+}
+function isRouteArrayType$1(context, typeNode) {
+	if (!typeNode) return false;
+	if (typeNode.type === "TSTypeReference" && isImportedTypeName$1(context, typeNode.typeName, ROUTES_TYPE_NAMES$1)) return true;
+	if (typeNode.type === "TSArrayType") return isRouteType$1(context, typeNode.elementType);
+	if (typeNode.type !== "TSTypeReference") return false;
+	if (getPropertyName(typeNode.typeName) !== "Array" && getPropertyName(typeNode.typeName) !== "ReadonlyArray") return false;
+	const [elementType] = getTypeParameterNodes$1(typeNode);
+	return isRouteType$1(context, elementType);
+}
+function getTypeAnnotation(node) {
+	const typeAnnotation = node?.typeAnnotation;
+	return typeAnnotation?.type === "TSTypeAnnotation" ? typeAnnotation.typeAnnotation : null;
+}
+const noRouteResolvers = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow Angular route resolvers in typed Route/Routes declarations.",
+			recommended: true
+		},
+		schema: [],
+		messages: { noRouteResolvers: "Avoid Angular route resolvers for data loading. Prefer component-level loading with signals or server-state helpers." }
+	},
+	createOnce(context) {
+		function reportResolveInRouteObject(routeObject) {
+			for (const property of routeObject.properties ?? []) {
+				if (property.type !== "Property" || property.computed) continue;
+				const propertyName = getPropertyName(property.key);
+				if (propertyName === "resolve") {
+					context.report({
+						node: property.key ?? property,
+						messageId: "noRouteResolvers"
+					});
+					continue;
+				}
+				if (propertyName === "children" && property.value?.type === "ArrayExpression") reportResolveInRouteArray(property.value);
+			}
+		}
+		function reportResolveInRouteArray(routeArray) {
+			for (const element of routeArray.elements ?? []) if (element?.type === "ObjectExpression") reportResolveInRouteObject(element);
+		}
+		return { VariableDeclarator(node) {
+			const declarator = node;
+			const typeNode = getTypeAnnotation(declarator.id);
+			if (isRouteArrayType$1(context, typeNode) && declarator.init?.type === "ArrayExpression") {
+				reportResolveInRouteArray(declarator.init);
+				return;
+			}
+			if (isRouteType$1(context, typeNode) && declarator.init?.type === "ObjectExpression") reportResolveInRouteObject(declarator.init);
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-ui-inheritance/index.ts
+const UI_DECORATORS = new Set(["Component", "Directive"]);
+function hasUiDecorator(context, classNode) {
+	if (!Array.isArray(classNode.decorators)) return false;
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, UI_DECORATORS));
+}
+const noUiInheritance = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow inheritance for Angular components and directives.",
+			recommended: true
+		},
+		schema: [],
+		messages: { noUiInheritance: "Avoid inheritance for Angular {{kind}} classes. Prefer composition with services or inject* helpers." }
+	},
+	createOnce(context) {
+		return { "ClassDeclaration, ClassExpression"(node) {
+			const classNode = node;
+			if (!classNode.superClass) return;
+			if (!hasUiDecorator(context, classNode)) return;
+			const kind = classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, new Set(["Component"]))) ? "component" : "directive";
+			context.report({
+				node: classNode.superClass,
+				messageId: "noUiInheritance",
+				data: { kind }
+			});
+		} };
+	}
+});
+//#endregion
 //#region src/rules/prefer-load-component-over-load-children/index.ts
-function isImportedTypeName(typeNode, localNames, routerNamespaces) {
-	const typeName = getTypeName(typeNode);
-	if (!typeName) return false;
-	if (!typeName.includes(".")) return localNames.has(typeName);
-	const [namespaceName, memberName] = typeName.split(".");
-	return routerNamespaces.has(namespaceName) && localNames.has(memberName);
+const ROUTE_TYPE_NAMES = new Set(["Route"]);
+const ROUTES_TYPE_NAMES = new Set(["Routes"]);
+function isImportedTypeName(context, typeNode, importedNames) {
+	if (typeNode?.type === "Identifier") {
+		const importedName = getImportedName(context, typeNode, "@angular/router");
+		return !!importedName && importedNames.has(importedName);
+	}
+	return typeNode?.type === "TSQualifiedName" && typeNode.left?.type === "Identifier" && isNamespaceImport(context, typeNode.left, "@angular/router") && importedNames.has(getPropertyName(typeNode.right) ?? "");
 }
 function getTypeParameterNodes(typeNode) {
 	return typeNode.typeParameters?.params ?? typeNode.typeArguments?.params ?? [];
 }
-function isRouteType(typeNode, imports) {
-	return typeNode?.type === "TSTypeReference" && isImportedTypeName(typeNode.typeName, imports.routeTypeLocalNames, imports.routerNamespaces);
+function isRouteType(context, typeNode) {
+	return typeNode?.type === "TSTypeReference" && isImportedTypeName(context, typeNode.typeName, ROUTE_TYPE_NAMES);
 }
-function isRouteArrayType(typeNode, imports) {
+function isRouteArrayType(context, typeNode) {
 	if (!typeNode) return false;
-	if (typeNode.type === "TSTypeReference" && isImportedTypeName(typeNode.typeName, imports.routesTypeLocalNames, imports.routerNamespaces)) return true;
-	if (typeNode.type === "TSArrayType") return isRouteType(typeNode.elementType, imports);
+	if (typeNode.type === "TSTypeReference" && isImportedTypeName(context, typeNode.typeName, ROUTES_TYPE_NAMES)) return true;
+	if (typeNode.type === "TSArrayType") return isRouteType(context, typeNode.elementType);
 	if (typeNode.type !== "TSTypeReference") return false;
-	const typeName = getTypeName(typeNode.typeName);
-	if (typeName !== "Array" && typeName !== "ReadonlyArray") return false;
+	if (getPropertyName(typeNode.typeName) !== "Array" && getPropertyName(typeNode.typeName) !== "ReadonlyArray") return false;
 	const [elementType] = getTypeParameterNodes(typeNode);
-	return isRouteType(elementType, imports);
+	return isRouteType(context, elementType);
 }
-function isRoutesTypeAnnotation(node, imports) {
+function isRoutesTypeAnnotation(context, node) {
 	const typeAnnotation = node?.typeAnnotation;
 	if (!typeAnnotation || typeAnnotation.type !== "TSTypeAnnotation") return false;
-	return isRouteArrayType(typeAnnotation.typeAnnotation, imports);
+	return isRouteArrayType(context, typeAnnotation.typeAnnotation);
 }
 function isExportedConstDeclarator(node) {
 	if (node.type !== "VariableDeclarator") return false;
@@ -1746,11 +1961,6 @@ const preferLoadComponentOverLoadChildren = defineRule({
 		messages: { avoidLoadChildren: "Avoid loadChildren in Routes arrays; prefer loadComponent for lazy-loading standalone route components." }
 	},
 	createOnce(context) {
-		const imports = {
-			routeTypeLocalNames: /* @__PURE__ */ new Set(),
-			routesTypeLocalNames: /* @__PURE__ */ new Set(),
-			routerNamespaces: /* @__PURE__ */ new Set()
-		};
 		function reportLoadChildrenInRouteObject(routeObject) {
 			for (const property of routeObject.properties ?? []) {
 				if (property.type !== "Property" || property.computed) continue;
@@ -1768,36 +1978,14 @@ const preferLoadComponentOverLoadChildren = defineRule({
 		function reportLoadChildrenInRouteArray(routeArray) {
 			for (const element of routeArray.elements ?? []) if (element?.type === "ObjectExpression") reportLoadChildrenInRouteObject(element);
 		}
-		return {
-			before() {
-				imports.routeTypeLocalNames.clear();
-				imports.routesTypeLocalNames.clear();
-				imports.routerNamespaces.clear();
-			},
-			ImportDeclaration(node) {
-				if (node.source?.value !== "@angular/router") return;
-				for (const specifier of node.specifiers ?? []) {
-					if (specifier.type === "ImportSpecifier") {
-						const importedName = getPropertyName(specifier.imported);
-						if (importedName === "Route") imports.routeTypeLocalNames.add(specifier.local.name);
-						if (importedName === "Routes") imports.routesTypeLocalNames.add(specifier.local.name);
-					}
-					if (specifier.type === "ImportNamespaceSpecifier") {
-						imports.routerNamespaces.add(specifier.local.name);
-						imports.routeTypeLocalNames.add("Route");
-						imports.routesTypeLocalNames.add("Routes");
-					}
-				}
-			},
-			VariableDeclarator(node) {
-				const declarator = node;
-				if (!isExportedConstDeclarator(declarator)) return;
-				if (declarator.id?.type !== "Identifier") return;
-				if (!isRoutesTypeAnnotation(declarator.id, imports)) return;
-				if (declarator.init?.type !== "ArrayExpression") return;
-				reportLoadChildrenInRouteArray(declarator.init);
-			}
-		};
+		return { VariableDeclarator(node) {
+			const declarator = node;
+			if (!isExportedConstDeclarator(declarator)) return;
+			if (declarator.id?.type !== "Identifier") return;
+			if (!isRoutesTypeAnnotation(context, declarator.id)) return;
+			if (declarator.init?.type !== "ArrayExpression") return;
+			reportLoadChildrenInRouteArray(declarator.init);
+		} };
 	}
 });
 //#endregion
@@ -1960,10 +2148,10 @@ const preferPrivateElements = defineRule({
 });
 //#endregion
 //#region src/rules/prefer-style-url/index.ts
-function isComponentDecoratorCall(context, node, componentLocalNames, angularNamespaces) {
+const COMPONENT_DECORATORS = new Set(["Component"]);
+function isComponentDecoratorCall(context, node) {
 	const callee = node.callee;
-	if (callee?.type === "Identifier") return componentLocalNames.has(callee.name) && !isShadowedIdentifier(context, callee);
-	return callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && angularNamespaces.has(callee.object.name) && !isShadowedIdentifier(context, callee.object) && getPropertyName(callee.property) === "Component";
+	return isImportedReference(context, callee, "@angular/core", COMPONENT_DECORATORS) || isImportedNamespaceMember(context, callee, "@angular/core", COMPONENT_DECORATORS);
 }
 function isSingleStyleFileNode(node) {
 	if (!node) return false;
@@ -1982,47 +2170,30 @@ const preferStyleUrl = defineRule({
 		messages: { preferStyleUrl: "Use styleUrl instead of styleUrls when a component has one style file." }
 	},
 	createOnce(context) {
-		const componentLocalNames = /* @__PURE__ */ new Set();
-		const angularNamespaces = /* @__PURE__ */ new Set();
-		return {
-			before() {
-				componentLocalNames.clear();
-				angularNamespaces.clear();
-			},
-			ImportDeclaration(node) {
-				if (node.source?.value !== "@angular/core") return;
-				for (const specifier of node.specifiers ?? []) {
-					if (specifier.type === "ImportSpecifier") {
-						if (getPropertyName(specifier.imported) === "Component") componentLocalNames.add(specifier.local.name);
-					}
-					if (specifier.type === "ImportNamespaceSpecifier") angularNamespaces.add(specifier.local.name);
-				}
-			},
-			CallExpression(node) {
-				const call = node;
-				if (!isComponentDecoratorCall(context, call, componentLocalNames, angularNamespaces)) return;
-				const metadata = call.arguments?.[0];
-				if (metadata?.type !== "ObjectExpression") return;
-				for (const property of metadata.properties ?? []) {
-					if (property.type !== "Property") continue;
-					if (property.computed) continue;
-					if (getPropertyName(property.key) !== "styleUrls") continue;
-					if (property.value?.type !== "ArrayExpression") continue;
-					const elements = property.value.elements?.filter(Boolean) ?? [];
-					if (elements.length !== 1) continue;
-					const styleFile = elements[0];
-					if (!isSingleStyleFileNode(styleFile)) continue;
-					const keyRange = getRange(property.key);
-					const valueRange = getRange(property.value);
-					const styleFileRange = getRange(styleFile);
-					context.report({
-						node: property.key,
-						messageId: "preferStyleUrl",
-						fix: keyRange && valueRange && styleFileRange ? (fixer) => [fixer.replaceTextRange(keyRange, "styleUrl"), fixer.replaceTextRange(valueRange, context.sourceCode.text.slice(styleFileRange[0], styleFileRange[1]))] : void 0
-					});
-				}
+		return { CallExpression(node) {
+			const call = node;
+			if (!isComponentDecoratorCall(context, call)) return;
+			const metadata = call.arguments?.[0];
+			if (metadata?.type !== "ObjectExpression") return;
+			for (const property of metadata.properties ?? []) {
+				if (property.type !== "Property") continue;
+				if (property.computed) continue;
+				if (getPropertyName(property.key) !== "styleUrls") continue;
+				if (property.value?.type !== "ArrayExpression") continue;
+				const elements = property.value.elements?.filter(Boolean) ?? [];
+				if (elements.length !== 1) continue;
+				const styleFile = elements[0];
+				if (!isSingleStyleFileNode(styleFile)) continue;
+				const keyRange = getRange(property.key);
+				const valueRange = getRange(property.value);
+				const styleFileRange = getRange(styleFile);
+				context.report({
+					node: property.key,
+					messageId: "preferStyleUrl",
+					fix: keyRange && valueRange && styleFileRange ? (fixer) => [fixer.replaceTextRange(keyRange, "styleUrl"), fixer.replaceTextRange(valueRange, context.sourceCode.text.slice(styleFileRange[0], styleFileRange[1]))] : void 0
+				});
 			}
-		};
+		} };
 	}
 });
 //#endregion
@@ -2036,24 +2207,21 @@ const FIELD_NODE_TYPES = new Set([
 	"FieldDefinition",
 	"PropertyDefinition"
 ]);
-function hasTargetDecorator(context, classNode, decoratorImports) {
+function hasTargetDecorator(context, classNode) {
 	if (!classNode || !Array.isArray(classNode.decorators)) return false;
-	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, decoratorImports));
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, TARGET_DECORATORS));
 }
-function isApiCallFromTrackedImports(context, node, importedApiLocalNames, angularNamespaces, apiNames) {
+function isApiCallFromAngularCore(context, node, apiNames) {
 	if (!node || node.type !== "CallExpression") return false;
 	const callee = node.callee;
-	if (callee?.type === "Identifier") return importedApiLocalNames.has(callee.name) && !isShadowedIdentifier(context, callee);
+	if (isImportedReference(context, callee, "@angular/core", apiNames)) return true;
 	if (callee?.type !== "MemberExpression") return false;
 	const supportsRequiredApi = [...INPUT_MODEL_APIS].some((name) => apiNames.has(name));
-	if (getPropertyName(callee.property) === "required" && callee.object?.type === "Identifier") return supportsRequiredApi && importedApiLocalNames.has(callee.object.name) && !isShadowedIdentifier(context, callee.object);
-	if (callee.object?.type === "Identifier" && angularNamespaces.has(callee.object.name)) {
-		const namespaceApiName = getPropertyName(callee.property);
-		return !!namespaceApiName && apiNames.has(namespaceApiName) && !isShadowedIdentifier(context, callee.object);
-	}
-	if (getPropertyName(callee.property) === "required" && callee.object?.type === "MemberExpression" && callee.object.object?.type === "Identifier" && angularNamespaces.has(callee.object.object.name)) {
+	if (getPropertyName(callee.property) === "required" && callee.object?.type === "Identifier") return supportsRequiredApi && isImportedReference(context, callee.object, "@angular/core", apiNames);
+	if (isImportedNamespaceMember(context, callee, "@angular/core", apiNames)) return true;
+	if (getPropertyName(callee.property) === "required" && callee.object?.type === "MemberExpression" && callee.object.object?.type === "Identifier") {
 		const namespaceApiName = getPropertyName(callee.object.property);
-		return supportsRequiredApi && !!namespaceApiName && apiNames.has(namespaceApiName) && !isShadowedIdentifier(context, callee.object.object);
+		return supportsRequiredApi && !!namespaceApiName && apiNames.has(namespaceApiName) && isImportedNamespaceMember(context, callee.object, "@angular/core", apiNames);
 	}
 	return false;
 }
@@ -2098,87 +2266,48 @@ const publicComponentInterface = defineRule({
 		}
 	},
 	createOnce(context) {
-		const inputModelLocalNames = /* @__PURE__ */ new Set();
-		const outputLocalNames = /* @__PURE__ */ new Set();
-		const injectLocalNames = /* @__PURE__ */ new Set();
-		const angularNamespaces = /* @__PURE__ */ new Set();
-		const decoratorImports = {
-			decoratorNames: TARGET_DECORATORS,
-			decoratorLocalNames: /* @__PURE__ */ new Set(),
-			angularNamespaces
-		};
-		return {
-			before() {
-				inputModelLocalNames.clear();
-				outputLocalNames.clear();
-				injectLocalNames.clear();
-				angularNamespaces.clear();
-				decoratorImports.decoratorLocalNames.clear();
-			},
-			ImportDeclaration(node) {
-				if (node.source?.value !== "@angular/core") return;
-				for (const specifier of node.specifiers ?? []) {
-					addAngularCoreDecoratorImport(specifier, TARGET_DECORATORS, decoratorImports);
-					if (specifier.type === "ImportSpecifier") {
-						const importedName = getPropertyName(specifier.imported);
-						if (!importedName) continue;
-						if (INPUT_MODEL_APIS.has(importedName)) inputModelLocalNames.add(specifier.local.name);
-						if (OUTPUT_APIS.has(importedName)) outputLocalNames.add(specifier.local.name);
-						if (INJECT_APIS.has(importedName)) injectLocalNames.add(specifier.local.name);
-						continue;
-					}
-					if (specifier.type === "ImportNamespaceSpecifier") angularNamespaces.add(specifier.local.name);
+		return { ClassBody(node) {
+			const classNode = node.parent;
+			if (!hasTargetDecorator(context, classNode)) return;
+			for (const member of node.body ?? []) {
+				if (!FIELD_NODE_TYPES.has(member.type)) continue;
+				const isInputModelMember = isApiCallFromAngularCore(context, member.value, INPUT_MODEL_APIS);
+				const isOutputMember = isApiCallFromAngularCore(context, member.value, OUTPUT_APIS);
+				if (isInputModelMember && isNonPublicMember(member)) {
+					context.report({
+						node: member.key ?? member,
+						messageId: "nonPublicInputModel",
+						data: { name: getPropertyName(member.key) ?? "member" },
+						fix: getVisibilityFix(context, member, "public")
+					});
+					continue;
 				}
-			},
-			ClassBody(node) {
-				const classNode = node.parent;
-				if (!hasTargetDecorator(context, classNode, decoratorImports)) return;
-				for (const member of node.body ?? []) {
-					if (!FIELD_NODE_TYPES.has(member.type)) continue;
-					const isInputModelMember = isApiCallFromTrackedImports(context, member.value, inputModelLocalNames, angularNamespaces, INPUT_MODEL_APIS);
-					const isOutputMember = isApiCallFromTrackedImports(context, member.value, outputLocalNames, angularNamespaces, OUTPUT_APIS);
-					if (isInputModelMember && isNonPublicMember(member)) {
-						context.report({
-							node: member.key ?? member,
-							messageId: "nonPublicInputModel",
-							data: { name: getPropertyName(member.key) ?? "member" },
-							fix: getVisibilityFix(context, member, "public")
-						});
-						continue;
-					}
-					if (isOutputMember && isNonPublicMember(member)) {
-						context.report({
-							node: member.key ?? member,
-							messageId: "nonPublicOutput",
-							data: { name: getPropertyName(member.key) ?? "member" },
-							fix: getVisibilityFix(context, member, "public")
-						});
-						continue;
-					}
-					if (isPublicMember(member) && isApiCallFromTrackedImports(context, member.value, injectLocalNames, angularNamespaces, INJECT_APIS)) context.report({
+				if (isOutputMember && isNonPublicMember(member)) {
+					context.report({
 						node: member.key ?? member,
-						messageId: "publicInjectMember",
+						messageId: "nonPublicOutput",
 						data: { name: getPropertyName(member.key) ?? "member" },
-						fix: getVisibilityFix(context, member, "protected")
+						fix: getVisibilityFix(context, member, "public")
 					});
+					continue;
 				}
-			},
-			"Program:exit"() {
-				inputModelLocalNames.clear();
-				outputLocalNames.clear();
-				injectLocalNames.clear();
-				angularNamespaces.clear();
+				if (isPublicMember(member) && isApiCallFromAngularCore(context, member.value, INJECT_APIS)) context.report({
+					node: member.key ?? member,
+					messageId: "publicInjectMember",
+					data: { name: getPropertyName(member.key) ?? "member" },
+					fix: getVisibilityFix(context, member, "protected")
+				});
 			}
-		};
+		} };
 	}
 });
 //#endregion
 //#region src/rules/restrict-injectable-provided-in/index.ts
 const ALLOWED_PROVIDED_IN_VALUES = new Set(["root", "platform"]);
 const INJECTABLE_DECORATORS = new Set(["Injectable"]);
-function getInjectableMetadata(context, node, decoratorImports) {
+function getInjectableMetadata(context, node) {
 	if (node.type !== "Decorator") return null;
-	if (!isAngularCoreDecorator(context, node, decoratorImports)) return null;
+	if (!isAngularCoreDecorator(context, node, INJECTABLE_DECORATORS)) return null;
 	const expression = node.expression;
 	if (expression?.type !== "CallExpression") return null;
 	const metadata = expression.arguments?.[0];
@@ -2203,41 +2332,26 @@ const restrictInjectableProvidedIn = defineRule({
 		messages: { disallowedProvidedIn: "@Injectable providedIn should be the literal 'root' or 'platform', not {{actual}}." }
 	},
 	createOnce(context) {
-		const decoratorImports = {
-			decoratorNames: INJECTABLE_DECORATORS,
-			decoratorLocalNames: /* @__PURE__ */ new Set(),
-			angularNamespaces: /* @__PURE__ */ new Set()
-		};
-		return {
-			before() {
-				decoratorImports.decoratorLocalNames.clear();
-				decoratorImports.angularNamespaces.clear();
-			},
-			ImportDeclaration(node) {
-				if (node.source?.value !== "@angular/core") return;
-				for (const specifier of node.specifiers ?? []) addAngularCoreDecoratorImport(specifier, INJECTABLE_DECORATORS, decoratorImports);
-			},
-			Decorator(node) {
-				const metadata = getInjectableMetadata(context, node, decoratorImports);
-				if (!metadata) return;
-				const providedInProperty = getProvidedInProperty(metadata);
-				if (!providedInProperty) return;
-				const value = providedInProperty.value;
-				if (isAllowedProvidedInValue(value)) return;
-				const actual = context.sourceCode.text.slice(value?.range?.[0] ?? providedInProperty.range?.[0] ?? 0, value?.range?.[1] ?? providedInProperty.range?.[1] ?? 0);
-				context.report({
-					node: value ?? providedInProperty,
-					messageId: "disallowedProvidedIn",
-					data: { actual: actual || "this value" }
-				});
-			}
-		};
+		return { Decorator(node) {
+			const metadata = getInjectableMetadata(context, node);
+			if (!metadata) return;
+			const providedInProperty = getProvidedInProperty(metadata);
+			if (!providedInProperty) return;
+			const value = providedInProperty.value;
+			if (isAllowedProvidedInValue(value)) return;
+			const actual = context.sourceCode.text.slice(value?.range?.[0] ?? providedInProperty.range?.[0] ?? 0, value?.range?.[1] ?? providedInProperty.range?.[1] ?? 0);
+			context.report({
+				node: value ?? providedInProperty,
+				messageId: "disallowedProvidedIn",
+				data: { actual: actual || "this value" }
+			});
+		} };
 	}
 });
 //#endregion
 //#region src/rules/rules-of-inject/index.ts
 const DEFAULT_ALLOWED_FUNCTION_NAMES = [];
-const DEFAULT_INJECT_FUNCTION_PREFIXES = ["injext"];
+const DEFAULT_INJECT_FUNCTION_PREFIXES = ["inject"];
 const DEFAULT_INJECT_FUNCTION_SUFFIXES = ["Guard"];
 const DEFAULT_RUNS_IN_INJECTION_CONTEXT = [];
 const ROUTER_CONTEXT_PROPERTY_NAMES = new Set([
@@ -2454,12 +2568,18 @@ const plugin = eslintCompatPlugin({
 	rules: {
 		"avoid-explicit-injection-context": avoidExplicitInjectionContext,
 		"avoid-explicit-subscription-management": avoidExplicitSubscriptionManagement,
+		"avoid-inappropriate-intimacy": avoidInappropriateIntimacy,
 		"avoid-ng-modules": avoidNgModules,
 		"avoid-rxjs-state-in-component": avoidRxjsStateInComponent,
 		"avoid-writing-signals-in-reactive-context": avoidWritingSignalsInReactiveContext,
 		"class-member-order": classMemberOrder,
-		"component-class-matches-filename": componentClassMatchesFilename,
+		"class-matches-filename": classMatchesFilename,
 		"component-resource-filenames": componentResourceFilenames,
+		"decorator-filename-suffix": decoratorFilenameSuffix,
+		"injects-tanstack-query-only-in-component-body": injectsTanstackQueryOnlyInComponentBody,
+		"no-resource-api": noResourceApi,
+		"no-route-resolvers": noRouteResolvers,
+		"no-ui-inheritance": noUiInheritance,
 		"prefer-load-component-over-load-children": preferLoadComponentOverLoadChildren,
 		"prefer-private-elements": preferPrivateElements,
 		"prefer-style-url": preferStyleUrl,