@benjavicente/lint-angular 0.0.4 → 0.0.5

package/README.md

@@ -4,30 +4,32 @@ Opinated Oxlint/ESLint-compatible plugin for Angular project rules.
 
 ## Rules
 
-
-| Rule                                                                                                  | Default | Fixable | Description                                                                                  |
-| ----------------------------------------------------------------------------------------------------- | ------- | ------- | -------------------------------------------------------------------------------------------- |
-| [`rules-of-inject`](./src/rules/rules-of-inject/)                                                     | ✅       |         | Restrict `inject()` usage to valid Angular injection contexts.                                |
-| [`avoid-explicit-injection-context`](./src/rules/avoid-explicit-injection-context/)                   | ✅       |         | Avoid explicit injection-context APIs such as `inject(Injector)` and `runInInjectionContext`. |
-| [`avoid-explicit-subscription-management`](./src/rules/avoid-explicit-subscription-management/)       | ✅       |         | Avoid storing and manually managing RxJS subscriptions in Angular classes.                    |
-| [`avoid-inappropriate-intimacy`](./src/rules/avoid-inappropriate-intimacy/)                           | ✅       |         | Avoid passing Angular component, directive, and service instances as function arguments.      |
-| [`avoid-ng-modules`](./src/rules/avoid-ng-modules/)                                                   | ✅       |         | Avoid NgModules in favor of standalone Angular APIs.                                          |
-| [`avoid-rxjs-state-in-component`](./src/rules/avoid-rxjs-state-in-component/)                         | ✅       |         | Avoid RxJS subjects for component and directive-local state.                                  |
-| [`avoid-writing-signals-in-reactive-context`](./src/rules/avoid-writing-signals-in-reactive-context/) | ✅       |         | Avoid writing to signals from reactive Angular contexts.                                      |
-| [`class-member-order`](./src/rules/class-member-order/)                                               | ✅       |         | Enforce a consistent member order for Angular classes.                                        |
-| [`class-matches-filename`](./src/rules/class-matches-filename/)                                       | ✅       |         | Require Angular class names to match component, directive, and service filenames.             |
-| [`component-resource-filenames`](./src/rules/component-resource-filenames/)                           | ✅       |         | Require component resource filenames to match the component TypeScript filename.              |
-| [`decorator-filename-suffix`](./src/rules/decorator-filename-suffix/)                                 | ✅       |         | Require Angular decorators to be declared in files with matching filename suffixes.           |
-| [`injects-tanstack-query-only-in-component-body`](./src/rules/injects-tanstack-query-only-in-component-body/) | ✅       |         | Require TanStack Query inject helpers to be direct component/directive class fields.          |
-| [`no-resource-api`](./src/rules/no-resource-api/)                                                     | ✅       |         | Avoid Angular resource APIs for server state.                                                 |
-| [`no-route-resolvers`](./src/rules/no-route-resolvers/)                                               | ✅       |         | Avoid Angular route resolvers for data loading.                                               |
-| [`no-ui-inheritance`](./src/rules/no-ui-inheritance/)                                                 | ✅       |         | Avoid inheritance for Angular components and directives.                                      |
-| [`prefer-private-elements`](./src/rules/prefer-private-elements/)                                     | ✅       | ✅      | Prefer ECMAScript private elements over TypeScript `private` members.                         |
-| [`prefer-load-component-over-load-children`](./src/rules/prefer-load-component-over-load-children/)   | ✅       |         | Prefer `loadComponent` for lazy routes that load a standalone component.                      |
-| [`prefer-style-url`](./src/rules/prefer-style-url/)                                                   | ✅       | ✅      | Prefer `styleUrl` when a component has exactly one stylesheet.                                |
-| [`public-component-interface`](./src/rules/public-component-interface/)                               | ✅       | ✅      | Keep component and directive signal interfaces public while hiding injected dependencies.     |
-| [`restrict-injectable-provided-in`](./src/rules/restrict-injectable-provided-in/)                     | ✅       |         | Restrict `@Injectable` `providedIn` values to `root` or `platform`.                           |
-
+| Rule                                                                                                          | Default | Fixable | Description                                                                                   |
+| ------------------------------------------------------------------------------------------------------------- | ------- | ------- | --------------------------------------------------------------------------------------------- |
+| [`rules-of-inject`](./src/rules/rules-of-inject/)                                                             | ✅      |         | Restrict `inject()` usage to valid Angular injection contexts.                                |
+| [`avoid-explicit-injection-context`](./src/rules/avoid-explicit-injection-context/)                           | ✅      |         | Avoid explicit injection-context APIs such as `inject(Injector)` and `runInInjectionContext`. |
+| [`avoid-explicit-subscription-management`](./src/rules/avoid-explicit-subscription-management/)               | ✅      |         | Avoid storing and manually managing RxJS subscriptions in Angular classes.                    |
+| [`avoid-inappropriate-intimacy`](./src/rules/avoid-inappropriate-intimacy/)                                   | ✅      |         | Avoid passing Angular component, directive, and service instances as function arguments.      |
+| [`avoid-ng-modules`](./src/rules/avoid-ng-modules/)                                                           | ✅      |         | Avoid NgModules in favor of standalone Angular APIs.                                          |
+| [`avoid-rxjs-state-in-component`](./src/rules/avoid-rxjs-state-in-component/)                                 | ✅      |         | Avoid RxJS subjects for component and directive-local state.                                  |
+| [`avoid-writing-signals-in-reactive-context`](./src/rules/avoid-writing-signals-in-reactive-context/)         | ✅      |         | Avoid writing to signals from reactive Angular contexts.                                      |
+| [`class-member-order`](./src/rules/class-member-order/)                                                       | ✅      |         | Enforce a consistent member order for Angular classes.                                        |
+| [`class-matches-filename`](./src/rules/class-matches-filename/)                                               | ✅      |         | Require Angular class names to match component, directive, and service filenames.             |
+| [`component-resource-filenames`](./src/rules/component-resource-filenames/)                                   | ✅      |         | Require component resource filenames to match the component TypeScript filename.              |
+| [`decorator-filename-suffix`](./src/rules/decorator-filename-suffix/)                                         | ✅      |         | Require Angular decorators to be declared in files with matching filename suffixes.           |
+| [`no-manual-change-detection`](./src/rules/no-manual-change-detection/)                                       | ✅      |         | Avoid manual Angular change detection through `ChangeDetectorRef`.                            |
+| [`no-resource-api`](./src/rules/no-resource-api/)                                                             | ✅      |         | Avoid Angular resource APIs for server state.                                                 |
+| [`no-route-resolvers`](./src/rules/no-route-resolvers/)                                                       | ✅      |         | Avoid Angular route resolvers for data loading.                                               |
+| [`no-ui-inheritance`](./src/rules/no-ui-inheritance/)                                                         | ✅      |         | Avoid inheritance for Angular components and directives.                                      |
+| [`prefer-private-elements`](./src/rules/prefer-private-elements/)                                             | ✅      | ✅      | Prefer ECMAScript private elements over TypeScript `private` members.                         |
+| [`prefer-load-component-over-load-children`](./src/rules/prefer-load-component-over-load-children/)           | ✅      |         | Prefer `loadComponent` for lazy routes that load a standalone component.                      |
+| [`prefer-style-url`](./src/rules/prefer-style-url/)                                                           | ✅      | ✅      | Prefer `styleUrl` when a component has exactly one stylesheet.                                |
+| [`public-component-interface`](./src/rules/public-component-interface/)                                       | ✅      | ✅      | Keep component and directive signal interfaces public while hiding injected dependencies.     |
+| [`restrict-injectable-provided-in`](./src/rules/restrict-injectable-provided-in/)                             | ✅      |         | Restrict `@Injectable` `providedIn` values to `root` or `platform`.                           |
+| [`tanstack-query-injects-only-in-component-body`](./src/rules/tanstack-query-injects-only-in-component-body/) | ✅      |         | Require TanStack Query inject helpers to be direct component/directive class fields.          |
+| [`tanstack-query-inlined-keys`](./src/rules/tanstack-query-inlined-keys/)                                     | ✅      |         | Require TanStack Query query option keys to be inline arrays.                                 |
+| [`tanstack-query-prefer-query-options`](./src/rules/tanstack-query-prefer-query-options/)                     | ✅      |         | Prefer `queryOptions()` to co-locate TanStack Query query keys and functions.                 |
+| [`vitest-no-incompatible-angular-testing-apis`](./src/rules/vitest-no-incompatible-angular-testing-apis/)     | ✅      |         | Disallow Angular testing APIs that are incompatible with Vitest.                              |
 
 ## Oxlint setup
 

package/dist/index.mjs

@@ -265,7 +265,7 @@ function classifyMember(context, element) {
 	if (element.type === "MethodDefinition") return 3;
 	return 3;
 }
-function getMemberName$1(node) {
+function getMemberName$2(node) {
 	if (!node) return null;
 	if (node.type === "Identifier" || node.type === "PrivateIdentifier") return node.name;
 	return null;
@@ -388,7 +388,7 @@ const classMemberOrder = defineRule({
 					element,
 					group,
 					effectiveGroup: group,
-					name: getMemberName$1(element.key),
+					name: getMemberName$2(element.key),
 					dependencies: collectThisMemberReferences(element.value)
 				});
 			}
@@ -423,17 +423,17 @@ 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"]);
-const INJECT_NAMES = new Set(["inject"]);
+const INJECT_NAMES$2 = new Set(["inject"]);
 const INJECTOR_NAMES = new Set(["Injector"]);
-function isInjectCall(context, callNode) {
+function isInjectCall$1(context, callNode) {
 	const callee = callNode.callee;
-	return isImportedReference(context, callee, "@angular/core", INJECT_NAMES) || isImportedNamespaceMember(context, callee, "@angular/core", INJECT_NAMES);
+	return isImportedReference(context, callee, "@angular/core", INJECT_NAMES$2) || isImportedNamespaceMember(context, callee, "@angular/core", INJECT_NAMES$2);
 }
 function isInjectorReference(context, node) {
 	return isImportedReference(context, node, "@angular/core", INJECTOR_NAMES) || isImportedNamespaceMember(context, node, "@angular/core", INJECTOR_NAMES);
 }
 function isDisallowedInjectInjector(context, callNode) {
-	if (!isInjectCall(context, callNode)) return false;
+	if (!isInjectCall$1(context, callNode)) return false;
 	return isInjectorReference(context, callNode.arguments?.[0]);
 }
 function isDisallowedRunInInjectionContext(context, callNode) {
@@ -490,7 +490,7 @@ const TARGET_DECORATORS$4 = new Set([
 	"Directive",
 	"Injectable"
 ]);
-const FIELD_NODE_TYPES$2 = new Set([
+const FIELD_NODE_TYPES$3 = new Set([
 	"AccessorProperty",
 	"FieldDefinition",
 	"PropertyDefinition"
@@ -644,10 +644,10 @@ function isUnmanagedSubscribeCall(context, node, rxjsSubscribableReferences, rxj
 	if (getPropertyName(callee.property) !== "subscribe") return false;
 	return isKnownRxjsSubscribableExpression(context, callee.object, rxjsSubscribableReferences, rxjsSubscribableLocalNames, rxjsNamespaces) && !isTakeUntilDestroyedSubscribe(node, takeUntilDestroyedLocalNames, interopNamespaces);
 }
-function walkNode$1(node, containingClass, visitor) {
+function walkNode$2(node, containingClass, visitor) {
 	if (!node) return;
 	if (Array.isArray(node)) {
-		for (const child of node) walkNode$1(child, containingClass, visitor);
+		for (const child of node) walkNode$2(child, containingClass, visitor);
 		return;
 	}
 	if (node !== containingClass && (node.type === "ClassDeclaration" || node.type === "ClassExpression")) return;
@@ -655,12 +655,12 @@ function walkNode$1(node, containingClass, visitor) {
 	for (const [key, value] of Object.entries(node)) {
 		if (key === "parent") continue;
 		if (!value || typeof value !== "object") continue;
-		walkNode$1(value, containingClass, visitor);
+		walkNode$2(value, containingClass, visitor);
 	}
 }
 function containsUnmanagedSubscribeCall(context, node, containingClass, rxjsSubscribableReferences, rxjsSubscribableLocalNames, rxjsNamespaces, takeUntilDestroyedLocalNames, interopNamespaces) {
 	let found = false;
-	walkNode$1(node, containingClass, (current) => {
+	walkNode$2(node, containingClass, (current) => {
 		if (isUnmanagedSubscribeCall(context, current, rxjsSubscribableReferences, rxjsSubscribableLocalNames, rxjsNamespaces, takeUntilDestroyedLocalNames, interopNamespaces)) {
 			found = true;
 			return false;
@@ -673,8 +673,8 @@ function collectRxjsSubscribableReferences(context, classBody, classNode, rxjsSu
 	let changed = true;
 	while (changed) {
 		changed = false;
-		walkNode$1(classBody, classNode, (node) => {
-			if (FIELD_NODE_TYPES$2.has(node.type)) {
+		walkNode$2(classBody, classNode, (node) => {
+			if (FIELD_NODE_TYPES$3.has(node.type)) {
 				const name = getDeclaredName(node.key);
 				if (!name || hasTrackedReferenceName(references, name)) return;
 				if (isObservableReferenceName(name) || hasRxjsSubscribableTypeReference(context, node.typeAnnotation?.typeAnnotation, rxjsSubscribableLocalNames, rxjsNamespaces) || isRxjsSubscribableConstructor(context, node.value, rxjsSubscribableLocalNames, rxjsNamespaces) || isKnownRxjsSubscribableExpression(context, node.value, references, rxjsSubscribableLocalNames, rxjsNamespaces)) {
@@ -705,8 +705,8 @@ function collectRxjsSubscribableReferences(context, classBody, classNode, rxjsSu
 }
 function collectSubscriptionReferences(context, classBody, classNode, subscriptionLocalNames, rxjsNamespaces, rxjsSubscribableReferences, rxjsSubscribableLocalNames, takeUntilDestroyedLocalNames, interopNamespaces) {
 	const references = /* @__PURE__ */ new Map();
-	walkNode$1(classBody, classNode, (node) => {
-		if (FIELD_NODE_TYPES$2.has(node.type)) {
+	walkNode$2(classBody, classNode, (node) => {
+		if (FIELD_NODE_TYPES$3.has(node.type)) {
 			const name = getDeclaredName(node.key);
 			if (!name) return;
 			if (hasSubscriptionTypeReference(context, node.typeAnnotation?.typeAnnotation, subscriptionLocalNames, rxjsNamespaces) || isSubscriptionConstructor(context, node.value, subscriptionLocalNames, rxjsNamespaces)) addTrackedReference(references, name, node.key);
@@ -796,8 +796,8 @@ const avoidExplicitSubscriptionManagement = defineRule({
 				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) => {
-					if (FIELD_NODE_TYPES$2.has(current.type)) {
+				walkNode$2(classBody, classNode, (current) => {
+					if (FIELD_NODE_TYPES$3.has(current.type)) {
 						if (hasSubscriptionTypeReference(context, current.typeAnnotation?.typeAnnotation, subscriptionLocalNames, rxjsNamespaces)) context.report({
 							node: current.key ?? current,
 							messageId: "explicitSubscriptionType"
@@ -1068,7 +1068,7 @@ const SUBJECT_NAMES = new Set([
 	"ReplaySubject",
 	"Subject"
 ]);
-const FIELD_NODE_TYPES$1 = new Set([
+const FIELD_NODE_TYPES$2 = new Set([
 	"AccessorProperty",
 	"FieldDefinition",
 	"PropertyDefinition"
@@ -1101,7 +1101,7 @@ function getSubjectKindFromConstructor(context, node) {
 	const memberName = getPropertyName(callee.property);
 	return SUBJECT_NAMES.has(memberName) ? memberName : null;
 }
-function getMemberName(node) {
+function getMemberName$1(node) {
 	const expression = unwrapExpression(node);
 	if (!expression) return null;
 	if (expression.type === "Identifier") return expression.name;
@@ -1131,17 +1131,17 @@ function isCallOnThisField(node, fields) {
 function isNgOnDestroyMethod(member) {
 	return member.type === "MethodDefinition" && getPropertyName(member.key) === "ngOnDestroy" && !!member.value;
 }
-function walkNode(node, visitor) {
+function walkNode$1(node, visitor) {
 	if (!node) return;
 	if (Array.isArray(node)) {
-		for (const child of node) walkNode(child, visitor);
+		for (const child of node) walkNode$1(child, visitor);
 		return;
 	}
 	visitor(node);
 	for (const [key, value] of Object.entries(node)) {
 		if (key === "parent") continue;
 		if (!value || typeof value !== "object") continue;
-		walkNode(value, visitor);
+		walkNode$1(value, visitor);
 	}
 }
 function getUsage(usages, fieldName) {
@@ -1159,8 +1159,8 @@ function getUsage(usages, fieldName) {
 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 (!FIELD_NODE_TYPES$2.has(member.type)) continue;
+		const fieldName = getMemberName$1(member.key);
 		if (!fieldName) continue;
 		const typeNode = member.typeAnnotation?.typeAnnotation;
 		const kind = getSubjectKindFromConstructor(context, member.value) ?? getSubjectKindFromType(context, typeNode);
@@ -1176,7 +1176,7 @@ function collectFieldUsages(classBody, fields) {
 	const usages = /* @__PURE__ */ new Map();
 	const ngOnDestroyMethods = /* @__PURE__ */ new Set();
 	for (const member of classBody.body ?? []) if (isNgOnDestroyMethod(member)) ngOnDestroyMethods.add(member.value);
-	walkNode(classBody, (node) => {
+	walkNode$1(classBody, (node) => {
 		const call = isCallOnThisField(node, fields);
 		if (!call) return;
 		const usage = getUsage(usages, call.fieldName);
@@ -1722,56 +1722,142 @@ const decoratorFilenameSuffix = defineRule({
 	}
 });
 //#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([
+//#region src/rules/no-manual-change-detection/index.ts
+const ANGULAR_CORE_SOURCE$1 = "@angular/core";
+const CHANGE_DETECTOR_REF_NAMES = new Set(["ChangeDetectorRef"]);
+const INJECT_NAMES$1 = new Set(["inject"]);
+const MANUAL_CHANGE_DETECTION_METHODS = new Set([
+	"checkNoChanges",
+	"detach",
+	"detectChanges",
+	"markForCheck",
+	"reattach"
+]);
+const FIELD_NODE_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 isChangeDetectorRefReference(context, node) {
+	return isImportedReference(context, node, ANGULAR_CORE_SOURCE$1, CHANGE_DETECTOR_REF_NAMES) || isImportedNamespaceMember(context, node, ANGULAR_CORE_SOURCE$1, CHANGE_DETECTOR_REF_NAMES);
 }
-function isTanstackQueryInjectCall(context, callNode) {
-	return [...TANSTACK_QUERY_SOURCES].some((source) => isImportedReference(context, callNode.callee, source, TANSTACK_QUERY_APIS));
+function isInjectCall(context, node) {
+	const expression = unwrapExpression(node);
+	if (expression?.type !== "CallExpression") return false;
+	return isImportedReference(context, expression.callee, ANGULAR_CORE_SOURCE$1, INJECT_NAMES$1) && isChangeDetectorRefReference(context, expression.arguments?.[0]);
 }
-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);
+function isChangeDetectorRefType(context, node) {
+	if (!node) return false;
+	if (node.type === "TSTypeReference") {
+		if (isChangeDetectorRefReference(context, node.typeName)) return true;
+		if (node.typeName?.type === "TSQualifiedName" && node.typeName.left?.type === "Identifier") return isNamespaceImport(context, node.typeName.left, ANGULAR_CORE_SOURCE$1) && getPropertyName(node.typeName.right) === "ChangeDetectorRef";
+	}
+	return false;
+}
+function getMemberName(node) {
+	const expression = unwrapExpression(node);
+	if (!expression) return null;
+	if (expression.type === "Identifier") return expression.name;
+	if (expression.type === "PrivateIdentifier") return expression.name;
+	return null;
+}
+function getParameterName(node) {
+	const parameter = node?.type === "TSParameterProperty" ? node.parameter : node;
+	if (parameter?.type === "Identifier") return parameter.name;
+	if (parameter?.type === "AssignmentPattern" && parameter.left?.type === "Identifier") return parameter.left.name;
+	return null;
+}
+function getParameterType(node) {
+	const parameter = node?.type === "TSParameterProperty" ? node.parameter : node;
+	if (parameter?.type === "AssignmentPattern") return parameter.left?.typeAnnotation?.typeAnnotation ?? null;
+	return parameter?.typeAnnotation?.typeAnnotation ?? null;
+}
+function getParameterBinding(node) {
+	const parameter = node?.type === "TSParameterProperty" ? node.parameter : node;
+	if (parameter?.type === "Identifier") return parameter;
+	if (parameter?.type === "AssignmentPattern" && parameter.left?.type === "Identifier") return parameter.left;
+	return null;
+}
+function collectChangeDetectorRefBindings(context, classNode) {
+	const fields = /* @__PURE__ */ new Set();
+	const parameters = /* @__PURE__ */ new Set();
+	for (const member of classNode.body?.body ?? []) {
+		if (member.type === "MethodDefinition" && getPropertyName(member.key) === "constructor") for (const parameter of member.value?.params ?? []) {
+			const name = getParameterName(parameter);
+			if (name && isChangeDetectorRefType(context, getParameterType(parameter))) {
+				const binding = getParameterBinding(parameter);
+				if (binding) parameters.add(binding);
+				if (parameter.type === "TSParameterProperty") fields.add(name);
+			}
+		}
+		if (!FIELD_NODE_TYPES$1.has(member.type)) continue;
+		const name = getMemberName(member.key);
+		if (!name) continue;
+		const typeNode = member.typeAnnotation?.typeAnnotation;
+		if (isChangeDetectorRefType(context, typeNode) || isInjectCall(context, member.value)) fields.add(name);
+	}
+	return {
+		fields,
+		parameters
+	};
+}
+function getManualChangeDetectionCall(context, callNode, bindings) {
+	const callee = unwrapExpression(callNode.callee);
+	if (callee?.type !== "MemberExpression") return null;
+	const methodName = getPropertyName(callee.property);
+	if (!methodName || !MANUAL_CHANGE_DETECTION_METHODS.has(methodName)) return null;
+	const object = unwrapExpression(callee.object);
+	if (object?.type === "Identifier") {
+		const binding = findNearestBindingIdentifier(context, object);
+		return binding && bindings.parameters.has(binding) ? {
+			methodName,
+			node: callee.property ?? callee
+		} : null;
+	}
+	if (object?.type !== "MemberExpression") return null;
+	if (object.object?.type !== "ThisExpression") return null;
+	const fieldName = getPropertyName(object.property);
+	return fieldName && bindings.fields.has(fieldName) ? {
+		methodName,
+		node: callee.property ?? callee
+	} : null;
 }
-const injectsTanstackQueryOnlyInComponentBody = defineRule({
+function walkNode(node, visitor) {
+	if (!node) return;
+	if (Array.isArray(node)) {
+		for (const child of node) walkNode(child, visitor);
+		return;
+	}
+	visitor(node);
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "parent") continue;
+		if (!value || typeof value !== "object") continue;
+		walkNode(value, visitor);
+	}
+}
+const noManualChangeDetection = defineRule({
 	meta: {
-		type: "problem",
+		type: "suggestion",
 		docs: {
-			description: "Require Angular TanStack Query injectQuery/injectMutation calls to be direct component/directive class fields.",
+			description: "Disallow manual Angular change detection through ChangeDetectorRef APIs.",
 			recommended: true
 		},
 		schema: [],
-		messages: { onlyInComponentBody: "Call {{name}} only as a direct class field initializer in an Angular component or directive." }
+		messages: { noManualChangeDetection: "Avoid manual change detection with ChangeDetectorRef. Prefer Angular's normal change detection triggers, signals, async bindings, or input updates." }
 	},
 	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" }
+		return { ClassDeclaration(node) {
+			const classNode = node;
+			const changeDetectorRefBindings = collectChangeDetectorRefBindings(context, classNode);
+			if (changeDetectorRefBindings.fields.size === 0 && changeDetectorRefBindings.parameters.size === 0) return;
+			walkNode(classNode.body, (child) => {
+				if (child.type !== "CallExpression") return;
+				const manualCall = getManualChangeDetectionCall(context, child, changeDetectorRefBindings);
+				if (!manualCall) return;
+				context.report({
+					node: manualCall.node,
+					messageId: "noManualChangeDetection"
+				});
 			});
 		} };
 	}
@@ -2198,7 +2284,7 @@ const preferStyleUrl = defineRule({
 });
 //#endregion
 //#region src/rules/public-component-interface/index.ts
-const TARGET_DECORATORS = new Set(["Component", "Directive"]);
+const TARGET_DECORATORS$1 = new Set(["Component", "Directive"]);
 const INPUT_MODEL_APIS = new Set(["input", "model"]);
 const OUTPUT_APIS = new Set(["output", "outputFromObservable"]);
 const INJECT_APIS = new Set(["inject"]);
@@ -2207,9 +2293,9 @@ const FIELD_NODE_TYPES = new Set([
 	"FieldDefinition",
 	"PropertyDefinition"
 ]);
-function hasTargetDecorator(context, classNode) {
+function hasTargetDecorator$1(context, classNode) {
 	if (!classNode || !Array.isArray(classNode.decorators)) return false;
-	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, TARGET_DECORATORS));
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, TARGET_DECORATORS$1));
 }
 function isApiCallFromAngularCore(context, node, apiNames) {
 	if (!node || node.type !== "CallExpression") return false;
@@ -2268,7 +2354,7 @@ const publicComponentInterface = defineRule({
 	createOnce(context) {
 		return { ClassBody(node) {
 			const classNode = node.parent;
-			if (!hasTargetDecorator(context, classNode)) return;
+			if (!hasTargetDecorator$1(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);
@@ -2416,18 +2502,18 @@ const INJECTION_CONTEXT_FUNCTION_TYPE_NAMES = new Set([
 	"RedirectFunction",
 	"ResolveFn"
 ]);
-const FUNCTION_TYPES = new Set([
+const FUNCTION_TYPES$1 = new Set([
 	"ArrowFunctionExpression",
 	"FunctionDeclaration",
 	"FunctionExpression"
 ]);
-const CLASS_FIELD_TYPES = new Set([
+const CLASS_FIELD_TYPES$1 = new Set([
 	"AccessorProperty",
 	"FieldDefinition",
 	"PropertyDefinition"
 ]);
 function isFunction(node) {
-	return !!node && FUNCTION_TYPES.has(node.type);
+	return !!node && FUNCTION_TYPES$1.has(node.type);
 }
 function getAncestors(context, node) {
 	return context.sourceCode.getAncestors(node);
@@ -2483,7 +2569,7 @@ function getFunctionContextTypeName(functionNode) {
 	const parent = skipTransparentExpressionParents(functionNode.parent);
 	if (parent?.type === "VariableDeclarator" && parent.id?.type === "Identifier") return getTypeName(parent.id.typeAnnotation?.typeAnnotation);
 	if (parent?.type === "Property" && parent.value === functionNode) return getTypeName(parent.typeAnnotation?.typeAnnotation);
-	if (parent && CLASS_FIELD_TYPES.has(parent.type) && parent.value === functionNode) return getTypeName(parent.typeAnnotation?.typeAnnotation);
+	if (parent && CLASS_FIELD_TYPES$1.has(parent.type) && parent.value === functionNode) return getTypeName(parent.typeAnnotation?.typeAnnotation);
 	return null;
 }
 function isTypedInjectionContextFunction(functionNode) {
@@ -2517,7 +2603,7 @@ function isConstructorFunction(functionNode) {
 	return functionNode.parent?.type === "MethodDefinition" && functionNode.parent.kind === "constructor" && functionNode.parent.value === functionNode;
 }
 function isDirectClassFieldInitializer(ancestors, nearestFunction) {
-	return !!ancestors.findLast((ancestor) => CLASS_FIELD_TYPES.has(ancestor.type)) && !nearestFunction;
+	return !!ancestors.findLast((ancestor) => CLASS_FIELD_TYPES$1.has(ancestor.type)) && !nearestFunction;
 }
 function hasSupportedAngularClassDecorator(classNode) {
 	if (!classNode) return false;
@@ -2561,6 +2647,494 @@ function isInjectLikeHelperCall(context, node, injectionContextApiLocalNames, in
 	if (runsInInjectionContextFunctionNames.has(callee.name)) return true;
 	return !injectionContextApiLocalNames.has(callee.name) && callee.name !== "inject" && (injectFunctionPrefixes.some((prefix) => callee.name.startsWith(prefix)) || injectFunctionSuffixes.some((suffix) => callee.name.endsWith(suffix)));
 }
+const rulesOfInject = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Require Angular APIs that depend on injection context to appear only in known injection contexts.",
+			recommended: true
+		},
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				allowedFunctionNames: {
+					type: "array",
+					items: { type: "string" },
+					default: DEFAULT_ALLOWED_FUNCTION_NAMES
+				},
+				checkUnimportedInject: {
+					type: "boolean",
+					default: false
+				},
+				injectFunctionPrefixes: {
+					type: "array",
+					items: { type: "string" },
+					default: DEFAULT_INJECT_FUNCTION_PREFIXES
+				},
+				injectFunctionSuffixes: {
+					type: "array",
+					items: { type: "string" },
+					default: DEFAULT_INJECT_FUNCTION_SUFFIXES
+				},
+				runsInInjectionContext: {
+					type: "array",
+					items: {
+						type: "object",
+						additionalProperties: false,
+						required: ["from", "imports"],
+						properties: {
+							from: { type: "string" },
+							imports: { anyOf: [{ const: "all" }, {
+								type: "array",
+								items: { type: "string" }
+							}] }
+						}
+					},
+					default: DEFAULT_RUNS_IN_INJECTION_CONTEXT
+				}
+			}
+		}],
+		messages: { disallowedInject: "Angular APIs that depend on injection context must be called from an injection context: a class field initializer or constructor in an Angular-decorated class, provider factory, InjectionToken factory, runInInjectionContext/runInContext callback, Angular route callback property (for example loadComponent/canActivate), an inject* or *Guard function, or configured allowed function." }
+	},
+	createOnce(context) {
+		const injectionContextApiLocalNames = /* @__PURE__ */ new Set();
+		const injectionContextApiNamespaceMembers = /* @__PURE__ */ new Map();
+		const runsInInjectionContextFunctionNames = /* @__PURE__ */ new Set();
+		let runsInInjectionContextRules = [];
+		return {
+			before() {
+				injectionContextApiLocalNames.clear();
+				injectionContextApiNamespaceMembers.clear();
+				runsInInjectionContextFunctionNames.clear();
+				runsInInjectionContextRules = (context.options[0] ?? {}).runsInInjectionContext ?? DEFAULT_RUNS_IN_INJECTION_CONTEXT;
+			},
+			ImportDeclaration(node) {
+				const source = node.source?.value;
+				const matchingRule = typeof source === "string" ? runsInInjectionContextRules.find((rule) => rule.from === source) : null;
+				if (matchingRule) for (const specifier of node.specifiers ?? []) {
+					if (specifier.type === "ImportSpecifier" && (matchingRule.imports === "all" || matchingRule.imports.includes(getPropertyName(specifier.imported) ?? ""))) runsInInjectionContextFunctionNames.add(specifier.local.name);
+					if ((specifier.type === "ImportDefaultSpecifier" || specifier.type === "ImportNamespaceSpecifier") && matchingRule.imports === "all") runsInInjectionContextFunctionNames.add(specifier.local.name);
+				}
+				const knownApiImports = typeof source === "string" ? getKnownInjectionContextApiImports(source) : null;
+				if (knownApiImports) for (const specifier of node.specifiers ?? []) {
+					if (specifier.type === "ImportSpecifier" && knownApiImports.has(getPropertyName(specifier.imported) ?? "")) injectionContextApiLocalNames.add(specifier.local.name);
+					if (specifier.type === "ImportNamespaceSpecifier") injectionContextApiNamespaceMembers.set(specifier.local.name, knownApiImports);
+				}
+			},
+			CallExpression(node) {
+				const options = context.options[0] ?? {};
+				const allowedFunctionNames = new Set(options.allowedFunctionNames ?? DEFAULT_ALLOWED_FUNCTION_NAMES);
+				const checkUnimportedInject = options.checkUnimportedInject ?? false;
+				const injectFunctionPrefixes = options.injectFunctionPrefixes ?? DEFAULT_INJECT_FUNCTION_PREFIXES;
+				const injectFunctionSuffixes = options.injectFunctionSuffixes ?? DEFAULT_INJECT_FUNCTION_SUFFIXES;
+				const inAllowedContext = isAllowedInjectionContext(context, node, allowedFunctionNames, injectFunctionPrefixes, injectFunctionSuffixes);
+				if (isInjectLikeHelperCall(context, node, injectionContextApiLocalNames, injectFunctionPrefixes, injectFunctionSuffixes, runsInInjectionContextFunctionNames) && !inAllowedContext) {
+					context.report({
+						node: node.callee,
+						messageId: "disallowedInject"
+					});
+					return;
+				}
+				if (!isKnownInjectionContextApiCall(context, node, injectionContextApiLocalNames, injectionContextApiNamespaceMembers, checkUnimportedInject)) return;
+				if (inAllowedContext) return;
+				context.report({
+					node: node.callee,
+					messageId: "disallowedInject"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/utilities/tanstack-query.ts
+const DEFAULT_TANSTACK_QUERY_SOURCES = [
+	"@tanstack/angular-query",
+	"@benjavicente/angular-query",
+	"@tanstack/angular-query-experimental"
+];
+const QUERY_CORE_SOURCE = "@tanstack/query-core";
+const QUERY_OPTIONS_BUILDERS = new Set(["queryOptions", "infiniteQueryOptions"]);
+function getTanstackQuerySources(options) {
+	return new Set(options.tanstackQuerySources ?? DEFAULT_TANSTACK_QUERY_SOURCES);
+}
+function getTanstackQueryImportName(context, node, sources) {
+	const expression = unwrapExpression(node);
+	if (expression?.type === "Identifier") {
+		for (const source of sources) {
+			const importedName = getImportedName(context, expression, source);
+			if (importedName) return importedName;
+		}
+		return null;
+	}
+	if (expression?.type !== "MemberExpression" || expression.object?.type !== "Identifier") return null;
+	for (const source of sources) if (isNamespaceImport(context, expression.object, source)) return getPropertyName(expression.property);
+	return null;
+}
+function isTanstackQueryImportedReference(context, node, sources, names) {
+	for (const source of sources) if (isImportedReference(context, node, source, names)) return true;
+	return false;
+}
+//#endregion
+//#region src/rules/tanstack-query-injects-only-in-component-body/index.ts
+const TARGET_DECORATORS = new Set(["Component", "Directive"]);
+const TANSTACK_QUERY_APIS = new Set(["injectQuery", "injectMutation"]);
+const CLASS_FIELD_TYPES = new Set([
+	"AccessorProperty",
+	"FieldDefinition",
+	"PropertyDefinition"
+]);
+const FUNCTION_TYPES = new Set([
+	"ArrowFunctionExpression",
+	"FunctionDeclaration",
+	"FunctionExpression"
+]);
+function hasTargetDecorator(context, classNode) {
+	if (!classNode || !Array.isArray(classNode.decorators)) return false;
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, TARGET_DECORATORS));
+}
+function isTanstackQueryInjectCall(context, callNode, tanstackQuerySources) {
+	return isTanstackQueryImportedReference(context, callNode.callee, tanstackQuerySources, TANSTACK_QUERY_APIS);
+}
+function isDirectComponentOrDirectiveFieldInitializer(context, callNode) {
+	const ancestors = context.sourceCode.getAncestors(callNode);
+	const classField = ancestors.findLast((ancestor) => CLASS_FIELD_TYPES.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.has(ancestor.type))) return false;
+	return hasTargetDecorator(context, classBody?.parent);
+}
+const tanstackQueryInjectsOnlyInComponentBody = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Require Angular TanStack Query injectQuery/injectMutation calls to be direct component/directive class fields.",
+			recommended: true
+		},
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: { tanstackQuerySources: {
+				type: "array",
+				items: { type: "string" },
+				default: DEFAULT_TANSTACK_QUERY_SOURCES
+			} }
+		}],
+		messages: { onlyInComponentBody: "Call {{name}} only as a direct class field initializer in an Angular component or directive." }
+	},
+	createOnce(context) {
+		let tanstackQuerySources = new Set(DEFAULT_TANSTACK_QUERY_SOURCES);
+		return {
+			before() {
+				tanstackQuerySources = getTanstackQuerySources(context.options?.[0] ?? {});
+			},
+			CallExpression(node) {
+				const callNode = node;
+				if (!isTanstackQueryInjectCall(context, callNode, tanstackQuerySources)) 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/tanstack-query-inlined-keys/index.ts
+function getProperty$1(node, name) {
+	for (const property of node.properties ?? []) if (property.type === "Property" && getPropertyName(property.key) === name) return property;
+	return null;
+}
+function isInlineArrayExpression$1(node) {
+	return unwrapExpression(node)?.type === "ArrayExpression";
+}
+const tanstackQueryInlinedKeys = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Require TanStack Query queryOptions() keys to be inline arrays.",
+			recommended: true
+		},
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: { tanstackQuerySources: {
+				type: "array",
+				items: { type: "string" },
+				default: DEFAULT_TANSTACK_QUERY_SOURCES
+			} }
+		}],
+		messages: { inlinedKeys: "Inline queryKey as an array in queryOptions(). Query keys are implementation details and should be read through query options." }
+	},
+	createOnce(context) {
+		let tanstackQuerySources = new Set(DEFAULT_TANSTACK_QUERY_SOURCES);
+		return {
+			before() {
+				tanstackQuerySources = getTanstackQuerySources(context.options?.[0] ?? {});
+			},
+			CallExpression(node) {
+				const callNode = node;
+				const importName = getTanstackQueryImportName(context, callNode.callee, tanstackQuerySources);
+				if (!importName || !QUERY_OPTIONS_BUILDERS.has(importName)) return;
+				const options = unwrapExpression(callNode.arguments?.[0]);
+				if (options?.type !== "ObjectExpression") return;
+				const queryKey = getProperty$1(options, "queryKey");
+				if (!queryKey || isInlineArrayExpression$1(queryKey.value)) return;
+				context.report({
+					node: queryKey.value ?? queryKey,
+					messageId: "inlinedKeys"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/tanstack-query-prefer-query-options/index.ts
+const ANGULAR_CORE_SOURCE = "@angular/core";
+const INJECT_NAMES = new Set(["inject"]);
+const QUERY_INJECT_APIS = new Set(["injectQuery", "injectInfiniteQuery"]);
+const QUERIES_INJECT_APIS = new Set(["injectQueries"]);
+const FILTER_INJECT_APIS = new Set(["injectIsFetching"]);
+const QUERY_CLIENT_OPTION_METHODS = new Set([
+	"ensureInfiniteQueryData",
+	"ensureQueryData",
+	"fetchInfiniteQuery",
+	"fetchQuery",
+	"prefetchInfiniteQuery",
+	"prefetchQuery"
+]);
+const QUERY_CLIENT_QUERY_KEY_METHODS = new Set([
+	"getQueryData",
+	"getQueryDefaults",
+	"getQueryState",
+	"setQueryData",
+	"setQueryDefaults"
+]);
+const QUERY_CLIENT_FILTER_METHODS = new Set([
+	"cancelQueries",
+	"getQueriesData",
+	"invalidateQueries",
+	"isFetching",
+	"refetchQueries",
+	"removeQueries",
+	"resetQueries",
+	"setQueriesData"
+]);
+const QUERY_CLIENT_NAMES = new Set(["QueryClient"]);
+const SKIP_TOKEN_NAMES = new Set(["skipToken"]);
+function getProperty(node, name) {
+	for (const property of node.properties ?? []) if (property.type === "Property" && getPropertyName(property.key) === name) return property;
+	return null;
+}
+function isObjectExpression(node) {
+	return unwrapExpression(node)?.type === "ObjectExpression";
+}
+function isInlineArrayExpression(node) {
+	return unwrapExpression(node)?.type === "ArrayExpression";
+}
+function isSkipToken(context, node, sources) {
+	const expression = unwrapExpression(node);
+	if (!expression) return false;
+	if (expression.type === "ConditionalExpression") return isSkipToken(context, expression.consequent, sources) || isSkipToken(context, expression.alternate, sources);
+	if (expression.type === "LogicalExpression") return isSkipToken(context, expression.left, sources) || isSkipToken(context, expression.right, sources);
+	for (const source of [...sources, QUERY_CORE_SOURCE]) if (isImportedReference(context, expression, source, SKIP_TOKEN_NAMES)) return true;
+	return false;
+}
+function hasObjectSpread(node) {
+	return (node.properties ?? []).some((property) => property.type === "SpreadElement");
+}
+function hasInlineQueryOptions(context, node, sources) {
+	if (getProperty(node, "queryKey")) return true;
+	const queryFn = getProperty(node, "queryFn");
+	if (!queryFn) return false;
+	return !(hasObjectSpread(node) && isSkipToken(context, queryFn.value, sources));
+}
+function hasInlineFilterQueryKey(node) {
+	const queryKey = getProperty(node, "queryKey")?.value;
+	return isInlineArrayExpression(queryKey);
+}
+function getReturnedObjectExpressions(node) {
+	const expression = unwrapExpression(node);
+	if (!expression) return [];
+	if (expression.type === "ObjectExpression") return [expression];
+	if (expression.type === "ArrowFunctionExpression" || expression.type === "FunctionExpression") return getReturnedObjectExpressions(expression.body);
+	if (expression.type === "BlockStatement") return (expression.body ?? []).flatMap((statement) => statement.type === "ReturnStatement" ? getReturnedObjectExpressions(statement.argument) : []);
+	if (expression.type === "ConditionalExpression") return [...getReturnedObjectExpressions(expression.consequent), ...getReturnedObjectExpressions(expression.alternate)];
+	if (expression.type === "LogicalExpression") return [...getReturnedObjectExpressions(expression.left), ...getReturnedObjectExpressions(expression.right)];
+	if (expression.type === "SequenceExpression") return (expression.expressions ?? []).flatMap((child) => getReturnedObjectExpressions(child));
+	return [];
+}
+function getQueryObjects(node) {
+	const expression = unwrapExpression(node);
+	if (!expression) return [];
+	if (expression.type === "ArrayExpression") return (expression.elements ?? []).filter(isObjectExpression).map((element) => unwrapExpression(element));
+	if (expression.type === "CallExpression" && expression.callee?.type === "MemberExpression" && getPropertyName(expression.callee.property) === "map") {
+		const mapper = expression.arguments?.[0];
+		if (mapper?.type === "ArrowFunctionExpression" || mapper?.type === "FunctionExpression") return getReturnedObjectExpressions(mapper);
+	}
+	return [];
+}
+function getBindingInitializer(binding) {
+	const parent = binding?.parent;
+	if (!parent) return null;
+	if (parent.type === "VariableDeclarator" && parent.id === binding) return parent.init ?? null;
+	if (parent.type === "AssignmentPattern" && parent.left === binding) return parent.right ?? null;
+	return null;
+}
+function getThisFieldInitializer(context, node, fieldName) {
+	const classBody = context.sourceCode.getAncestors(node).findLast((ancestor) => ancestor.type === "ClassBody");
+	if (!classBody) return null;
+	for (const member of classBody.body ?? []) if (getPropertyName(member.key) === fieldName) return member.value ?? null;
+	return null;
+}
+function isQueryClientReference(context, node, sources) {
+	const expression = unwrapExpression(node);
+	if (!expression) return false;
+	return isTanstackQueryImportedReference(context, expression, sources, QUERY_CLIENT_NAMES) || isImportedReference(context, expression, "@tanstack/query-core", QUERY_CLIENT_NAMES);
+}
+function isInjectQueryClientCall(context, node, sources) {
+	const expression = unwrapExpression(node);
+	return expression?.type === "CallExpression" && isImportedReference(context, expression.callee, ANGULAR_CORE_SOURCE, INJECT_NAMES) && isQueryClientReference(context, expression.arguments?.[0], sources);
+}
+function isQueryClientSource(context, node, sources) {
+	const expression = unwrapExpression(node);
+	if (!expression) return false;
+	if (expression.type === "NewExpression") return isQueryClientReference(context, expression.callee, sources);
+	return isInjectQueryClientCall(context, expression, sources);
+}
+function resolveQueryClientSource(context, node, sources) {
+	let current = unwrapExpression(node);
+	const visited = /* @__PURE__ */ new Set();
+	while (current && !visited.has(current)) {
+		visited.add(current);
+		if (isQueryClientSource(context, current, sources)) return current;
+		if (current.type === "Identifier") {
+			const initializer = getBindingInitializer(findNearestBindingIdentifier(context, current));
+			if (!initializer) return current;
+			current = unwrapExpression(initializer);
+			continue;
+		}
+		if (current.type === "MemberExpression" && current.object?.type === "ThisExpression") {
+			const initializer = getThisFieldInitializer(context, current, getPropertyName(current.property) ?? "");
+			if (!initializer) return current;
+			current = unwrapExpression(initializer);
+			continue;
+		}
+		return current;
+	}
+	return current ?? null;
+}
+function isTanstackQueryClient(context, node, sources) {
+	return isQueryClientSource(context, resolveQueryClientSource(context, node, sources), sources);
+}
+function reportInlineQueryOptions(context, node, sources) {
+	const expression = unwrapExpression(node);
+	if (!expression || expression.type !== "ObjectExpression") return;
+	if (!hasInlineQueryOptions(context, expression, sources)) return;
+	context.report({
+		node: expression,
+		messageId: "preferQueryOptions"
+	});
+}
+function reportInlineFilterQueryKey(context, node) {
+	const expression = unwrapExpression(node);
+	if (!expression || expression.type !== "ObjectExpression") return;
+	if (!hasInlineFilterQueryKey(expression)) return;
+	context.report({
+		node: expression,
+		messageId: "preferQueryOptionsQueryKey"
+	});
+}
+const tanstackQueryPreferQueryOptions = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Prefer queryOptions() to co-locate TanStack Query queryKey and queryFn.",
+			recommended: true
+		},
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: { tanstackQuerySources: {
+				type: "array",
+				items: { type: "string" },
+				default: DEFAULT_TANSTACK_QUERY_SOURCES
+			} }
+		}],
+		messages: {
+			preferQueryOptions: "Prefer using queryOptions() or infiniteQueryOptions() to co-locate queryKey and queryFn.",
+			preferQueryOptionsQueryKey: "Prefer referencing a queryKey from a queryOptions() result instead of typing it manually."
+		}
+	},
+	createOnce(context) {
+		let tanstackQuerySources = new Set(DEFAULT_TANSTACK_QUERY_SOURCES);
+		return {
+			before() {
+				tanstackQuerySources = getTanstackQuerySources(context.options?.[0] ?? {});
+			},
+			CallExpression(node) {
+				const callNode = node;
+				const importName = getTanstackQueryImportName(context, callNode.callee, tanstackQuerySources);
+				if (importName && QUERY_OPTIONS_BUILDERS.has(importName)) return;
+				if (importName && QUERY_INJECT_APIS.has(importName)) {
+					for (const objectExpression of getReturnedObjectExpressions(callNode.arguments?.[0])) reportInlineQueryOptions(context, objectExpression, tanstackQuerySources);
+					return;
+				}
+				if (importName && QUERIES_INJECT_APIS.has(importName)) {
+					for (const objectExpression of getReturnedObjectExpressions(callNode.arguments?.[0])) {
+						const queries = getProperty(objectExpression, "queries")?.value;
+						for (const query of getQueryObjects(queries)) reportInlineQueryOptions(context, query, tanstackQuerySources);
+					}
+					return;
+				}
+				if (importName && FILTER_INJECT_APIS.has(importName)) {
+					reportInlineFilterQueryKey(context, callNode.arguments?.[0]);
+					return;
+				}
+				const callee = unwrapExpression(callNode.callee);
+				if (callee?.type !== "MemberExpression" || !isTanstackQueryClient(context, callee.object, tanstackQuerySources)) return;
+				const method = getPropertyName(callee.property);
+				const options = callNode.arguments?.[0];
+				if (QUERY_CLIENT_OPTION_METHODS.has(method ?? "")) {
+					reportInlineQueryOptions(context, options, tanstackQuerySources);
+					return;
+				}
+				if (QUERY_CLIENT_QUERY_KEY_METHODS.has(method ?? "") && isInlineArrayExpression(options)) {
+					context.report({
+						node: unwrapExpression(options) ?? options,
+						messageId: "preferQueryOptionsQueryKey"
+					});
+					return;
+				}
+				if (QUERY_CLIENT_FILTER_METHODS.has(method ?? "")) reportInlineFilterQueryKey(context, options);
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/vitest-no-incompatible-angular-testing-apis/index.ts
+const ANGULAR_TESTING_SOURCE = "@angular/core/testing";
+const VITEST_INCOMPATIBLE_APIS = new Set([
+	"discardPeriodicTasks",
+	"fakeAsync",
+	"flush",
+	"flushMicrotasks",
+	"resetFakeAsyncZone",
+	"tick",
+	"waitForAsync"
+]);
+function getIncompatibleImportName(specifier) {
+	if (specifier.type !== "ImportSpecifier") return null;
+	const importedName = getPropertyName(specifier.imported);
+	return importedName && VITEST_INCOMPATIBLE_APIS.has(importedName) ? importedName : null;
+}
+function isIncompatibleNamespaceCall(context, callNode) {
+	return isImportedNamespaceMember(context, callNode.callee, ANGULAR_TESTING_SOURCE, VITEST_INCOMPATIBLE_APIS);
+}
 //#endregion
 //#region src/index.ts
 const plugin = eslintCompatPlugin({
@@ -2576,7 +3150,7 @@ const plugin = eslintCompatPlugin({
 		"class-matches-filename": classMatchesFilename,
 		"component-resource-filenames": componentResourceFilenames,
 		"decorator-filename-suffix": decoratorFilenameSuffix,
-		"injects-tanstack-query-only-in-component-body": injectsTanstackQueryOnlyInComponentBody,
+		"no-manual-change-detection": noManualChangeDetection,
 		"no-resource-api": noResourceApi,
 		"no-route-resolvers": noRouteResolvers,
 		"no-ui-inheritance": noUiInheritance,
@@ -2585,100 +3159,42 @@ const plugin = eslintCompatPlugin({
 		"prefer-style-url": preferStyleUrl,
 		"public-component-interface": publicComponentInterface,
 		"restrict-injectable-provided-in": restrictInjectableProvidedIn,
-		"rules-of-inject": defineRule({
+		"rules-of-inject": rulesOfInject,
+		"tanstack-query-injects-only-in-component-body": tanstackQueryInjectsOnlyInComponentBody,
+		"tanstack-query-inlined-keys": tanstackQueryInlinedKeys,
+		"tanstack-query-prefer-query-options": tanstackQueryPreferQueryOptions,
+		"vitest-no-incompatible-angular-testing-apis": defineRule({
 			meta: {
 				type: "problem",
 				docs: {
-					description: "Require Angular APIs that depend on injection context to appear only in known injection contexts.",
+					description: "Disallow Angular testing APIs that depend on Zone.js and are incompatible with Vitest.",
 					recommended: true
 				},
-				schema: [{
-					type: "object",
-					additionalProperties: false,
-					properties: {
-						allowedFunctionNames: {
-							type: "array",
-							items: { type: "string" },
-							default: DEFAULT_ALLOWED_FUNCTION_NAMES
-						},
-						checkUnimportedInject: {
-							type: "boolean",
-							default: false
-						},
-						injectFunctionPrefixes: {
-							type: "array",
-							items: { type: "string" },
-							default: DEFAULT_INJECT_FUNCTION_PREFIXES
-						},
-						injectFunctionSuffixes: {
-							type: "array",
-							items: { type: "string" },
-							default: DEFAULT_INJECT_FUNCTION_SUFFIXES
-						},
-						runsInInjectionContext: {
-							type: "array",
-							items: {
-								type: "object",
-								additionalProperties: false,
-								required: ["from", "imports"],
-								properties: {
-									from: { type: "string" },
-									imports: { anyOf: [{ const: "all" }, {
-										type: "array",
-										items: { type: "string" }
-									}] }
-								}
-							},
-							default: DEFAULT_RUNS_IN_INJECTION_CONTEXT
-						}
-					}
-				}],
-				messages: { disallowedInject: "Angular APIs that depend on injection context must be called from an injection context: a class field initializer or constructor in an Angular-decorated class, provider factory, InjectionToken factory, runInInjectionContext/runInContext callback, Angular route callback property (for example loadComponent/canActivate), an inject* or *Guard function, or configured allowed function." }
+				schema: [],
+				messages: { vitestNoIncompatibleAngularTestingApi: "Avoid Angular testing API '{{name}}'. It depends on Zone.js and is not compatible with Angular tests running on Vitest." }
 			},
 			createOnce(context) {
-				const injectionContextApiLocalNames = /* @__PURE__ */ new Set();
-				const injectionContextApiNamespaceMembers = /* @__PURE__ */ new Map();
-				const runsInInjectionContextFunctionNames = /* @__PURE__ */ new Set();
-				let runsInInjectionContextRules = [];
 				return {
-					before() {
-						injectionContextApiLocalNames.clear();
-						injectionContextApiNamespaceMembers.clear();
-						runsInInjectionContextFunctionNames.clear();
-						runsInInjectionContextRules = (context.options[0] ?? {}).runsInInjectionContext ?? DEFAULT_RUNS_IN_INJECTION_CONTEXT;
-					},
 					ImportDeclaration(node) {
-						const source = node.source?.value;
-						const matchingRule = typeof source === "string" ? runsInInjectionContextRules.find((rule) => rule.from === source) : null;
-						if (matchingRule) for (const specifier of node.specifiers ?? []) {
-							if (specifier.type === "ImportSpecifier" && (matchingRule.imports === "all" || matchingRule.imports.includes(getPropertyName(specifier.imported) ?? ""))) runsInInjectionContextFunctionNames.add(specifier.local.name);
-							if ((specifier.type === "ImportDefaultSpecifier" || specifier.type === "ImportNamespaceSpecifier") && matchingRule.imports === "all") runsInInjectionContextFunctionNames.add(specifier.local.name);
-						}
-						const knownApiImports = typeof source === "string" ? getKnownInjectionContextApiImports(source) : null;
-						if (knownApiImports) for (const specifier of node.specifiers ?? []) {
-							if (specifier.type === "ImportSpecifier" && knownApiImports.has(getPropertyName(specifier.imported) ?? "")) injectionContextApiLocalNames.add(specifier.local.name);
-							if (specifier.type === "ImportNamespaceSpecifier") injectionContextApiNamespaceMembers.set(specifier.local.name, knownApiImports);
-						}
-					},
-					CallExpression(node) {
-						const options = context.options[0] ?? {};
-						const allowedFunctionNames = new Set(options.allowedFunctionNames ?? DEFAULT_ALLOWED_FUNCTION_NAMES);
-						const checkUnimportedInject = options.checkUnimportedInject ?? false;
-						const injectFunctionPrefixes = options.injectFunctionPrefixes ?? DEFAULT_INJECT_FUNCTION_PREFIXES;
-						const injectFunctionSuffixes = options.injectFunctionSuffixes ?? DEFAULT_INJECT_FUNCTION_SUFFIXES;
-						const inAllowedContext = isAllowedInjectionContext(context, node, allowedFunctionNames, injectFunctionPrefixes, injectFunctionSuffixes);
-						if (isInjectLikeHelperCall(context, node, injectionContextApiLocalNames, injectFunctionPrefixes, injectFunctionSuffixes, runsInInjectionContextFunctionNames) && !inAllowedContext) {
+						const importNode = node;
+						if (importNode.source?.value !== ANGULAR_TESTING_SOURCE) return;
+						for (const specifier of importNode.specifiers ?? []) {
+							const name = getIncompatibleImportName(specifier);
+							if (!name) continue;
 							context.report({
-								node: node.callee,
-								messageId: "disallowedInject"
+								node: specifier,
+								messageId: "vitestNoIncompatibleAngularTestingApi",
+								data: { name }
 							});
-							return;
 						}
-						if (!isKnownInjectionContextApiCall(context, node, injectionContextApiLocalNames, injectionContextApiNamespaceMembers, checkUnimportedInject)) return;
-						if (inAllowedContext) return;
+					},
+					CallExpression(node) {
+						const callNode = node;
+						if (!isIncompatibleNamespaceCall(context, callNode)) return;
 						context.report({
-							node: node.callee,
-							messageId: "disallowedInject"
+							node: callNode.callee,
+							messageId: "vitestNoIncompatibleAngularTestingApi",
+							data: { name: getPropertyName(callNode.callee?.property) ?? "this API" }
 						});
 					}
 				};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@benjavicente/lint-angular",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Oxlint/ESLint-compatible rules for Angular.",
   "keywords": [
     "angular",
@@ -30,7 +30,7 @@
   "devDependencies": {
     "@types/estree": "^1.0.9",
     "typescript": "^6.0.3",
-    "vite-plus": "^0.1.20",
+    "vite-plus": "^0.1.22",
     "vitest": "npm:@voidzero-dev/vite-plus-test@^0.1.20",
     "oxlint-vitest-rule-tester": "0.0.1"
   },