@benjavicente/lint-angular 0.0.3 → 0.0.5

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;
@@ -222,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"
@@ -254,7 +254,7 @@ 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$1.has(element.type)) {
+	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;
@@ -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;
@@ -335,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;
@@ -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) {
@@ -485,12 +485,12 @@ const avoidExplicitInjectionContext = defineRule({
 });
 //#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"
 ]);
-const FIELD_NODE_TYPES$2 = new Set([
+const FIELD_NODE_TYPES$3 = new Set([
 	"AccessorProperty",
 	"FieldDefinition",
 	"PropertyDefinition"
@@ -502,9 +502,9 @@ const RXJS_SUBSCRIBABLE_NAMES = new Set([
 	"ReplaySubject",
 	"Subject"
 ]);
-function hasTargetDecorator$3(context, classNode) {
+function hasTargetDecorator$4(context, classNode) {
 	if (!classNode || !Array.isArray(classNode.decorators)) return false;
-	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, TARGET_DECORATORS$2));
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, TARGET_DECORATORS$4));
 }
 function hasSubscriptionTypeReference(context, node, subscriptionLocalNames, rxjsNamespaces) {
 	if (!node) return false;
@@ -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);
@@ -793,11 +793,11 @@ const avoidExplicitSubscriptionManagement = defineRule({
 			ClassBody(node) {
 				const classBody = node;
 				const classNode = classBody.parent;
-				if (!classNode || !hasTargetDecorator$3(context, classNode)) 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) => {
-					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"
@@ -845,6 +845,46 @@ 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;
@@ -1022,20 +1062,20 @@ const avoidNgModules = defineRule({
 });
 //#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",
 	"Subject"
 ]);
-const FIELD_NODE_TYPES$1 = new Set([
+const FIELD_NODE_TYPES$2 = new Set([
 	"AccessorProperty",
 	"FieldDefinition",
 	"PropertyDefinition"
 ]);
-function hasTargetDecorator$2(context, classNode) {
+function hasTargetDecorator$3(context, classNode) {
 	if (!classNode || !Array.isArray(classNode.decorators)) return false;
-	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, TARGET_DECORATORS$1));
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, TARGET_DECORATORS$2));
 }
 function getImportedSubjectKind(context, node) {
 	const importedName = getImportedName(context, node, "rxjs");
@@ -1061,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;
@@ -1091,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) {
@@ -1119,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);
@@ -1136,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);
@@ -1174,7 +1214,7 @@ const avoidRxjsStateInComponent = defineRule({
 		return { ClassBody(node) {
 			const classBody = node;
 			const classNode = classBody.parent;
-			if (!hasTargetDecorator$2(context, classNode)) return;
+			if (!hasTargetDecorator$3(context, classNode)) return;
 			const fields = collectSubjectFields(context, classBody);
 			const usages = collectFieldUsages(classBody, fields);
 			for (const [fieldName, field] of fields) {
@@ -1417,7 +1457,7 @@ function getNodeName(node) {
 function getBaseFilename$1(filename) {
 	return filename.split(/[/\\]/u).at(-1) ?? filename;
 }
-function hasTargetDecorator$1(context, classNode, decoratorNames) {
+function hasTargetDecorator$2(context, classNode, decoratorNames) {
 	if (!Array.isArray(classNode.decorators)) return false;
 	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, decoratorNames));
 }
@@ -1471,7 +1511,7 @@ const classMatchesFilename = defineRule({
 			ClassDeclaration(node) {
 				if (!fileMatcher) return;
 				const classNode = node;
-				if (hasTargetDecorator$1(context, classNode, fileDecoratorNames)) decoratedClasses.push(classNode);
+				if (hasTargetDecorator$2(context, classNode, fileDecoratorNames)) decoratedClasses.push(classNode);
 			},
 			after() {
 				const filename = context.filename ?? "";
@@ -1682,6 +1722,284 @@ const decoratorFilenameSuffix = defineRule({
 	}
 });
 //#endregion
+//#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"
+]);
+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 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 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;
+}
+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: "suggestion",
+		docs: {
+			description: "Disallow manual Angular change detection through ChangeDetectorRef APIs.",
+			recommended: true
+		},
+		schema: [],
+		messages: { noManualChangeDetection: "Avoid manual change detection with ChangeDetectorRef. Prefer Angular's normal change detection triggers, signals, async bindings, or input updates." }
+	},
+	createOnce(context) {
+		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"
+				});
+			});
+		} };
+	}
+});
+//#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
 const ROUTE_TYPE_NAMES = new Set(["Route"]);
 const ROUTES_TYPE_NAMES = new Set(["Routes"]);
@@ -1966,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"]);
@@ -1975,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;
@@ -2036,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);
@@ -2119,7 +2437,7 @@ const restrictInjectableProvidedIn = defineRule({
 //#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([
@@ -2184,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);
@@ -2251,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) {
@@ -2285,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;
@@ -2329,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({
@@ -2336,6 +3142,7 @@ 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,
@@ -2343,105 +3150,51 @@ const plugin = eslintCompatPlugin({
 		"class-matches-filename": classMatchesFilename,
 		"component-resource-filenames": componentResourceFilenames,
 		"decorator-filename-suffix": decoratorFilenameSuffix,
+		"no-manual-change-detection": noManualChangeDetection,
+		"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,
 		"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" }
 						});
 					}
 				};