@benjavicente/lint-angular 0.0.1 → 0.0.3

package/dist/index.mjs

@@ -23,6 +23,194 @@ function getRange(node) {
 	if (typeof node.start === "number" && typeof node.end === "number") return [node.start, node.end];
 	return null;
 }
+function getNodeStart(node) {
+	if (typeof node.start === "number") return node.start;
+	if (Array.isArray(node.range) && typeof node.range[0] === "number") return node.range[0];
+	return null;
+}
+function getTypeName(node) {
+	if (!node) return null;
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "TSTypeReference") return getTypeName(node.typeName);
+	if (node.type === "TSQualifiedName") {
+		const left = getTypeName(node.left);
+		const right = getTypeName(node.right);
+		return left && right ? `${left}.${right}` : right ?? left;
+	}
+	return null;
+}
+const TRANSPARENT_EXPRESSION_NODE_TYPES = new Set([
+	"ChainExpression",
+	"ParenthesizedExpression",
+	"TSAsExpression",
+	"TSInstantiationExpression",
+	"TSNonNullExpression",
+	"TSSatisfiesExpression",
+	"TSTypeAssertion"
+]);
+function unwrapExpression(node) {
+	let current = node;
+	while (current && TRANSPARENT_EXPRESSION_NODE_TYPES.has(current.type)) current = current.expression ?? current.argument ?? current.object ?? current.callee ?? current.typeAnnotation ?? null;
+	return current ?? null;
+}
+//#endregion
+//#region src/utilities/scope.ts
+const FUNCTION_TYPES$1 = new Set([
+	"ArrowFunctionExpression",
+	"FunctionDeclaration",
+	"FunctionExpression"
+]);
+function isFunction$1(node) {
+	return !!node && FUNCTION_TYPES$1.has(node.type);
+}
+function addBindingIdentifierNodes(node, identifiers) {
+	if (!node) return;
+	if (node.type === "Identifier") {
+		identifiers.push(node);
+		return;
+	}
+	if (node.type === "AssignmentPattern") {
+		addBindingIdentifierNodes(node.left, identifiers);
+		return;
+	}
+	if (node.type === "RestElement" || node.type === "TSParameterProperty") {
+		addBindingIdentifierNodes(node.argument ?? node.parameter, identifiers);
+		return;
+	}
+	if (node.type === "ArrayPattern") {
+		for (const element of node.elements ?? []) addBindingIdentifierNodes(element, identifiers);
+		return;
+	}
+	if (node.type === "ObjectPattern") for (const property of node.properties ?? []) if (property.type === "Property") addBindingIdentifierNodes(property.value, identifiers);
+	else addBindingIdentifierNodes(property.argument, identifiers);
+}
+function getBindingIdentifierNodes(node) {
+	const identifiers = [];
+	addBindingIdentifierNodes(node, identifiers);
+	return identifiers;
+}
+function getBindingNames(node) {
+	return new Set(getBindingIdentifierNodes(node).map((identifier) => identifier.name));
+}
+function hasBindingName(node, name) {
+	return getBindingNames(node).has(name);
+}
+function getMatchingBindingIdentifier(node, name) {
+	return getBindingIdentifierNodes(node).find((identifier) => identifier.name === name) ?? null;
+}
+function isBeforeReference(node, reference) {
+	const nodeStart = getNodeStart(node);
+	const referenceStart = getNodeStart(reference);
+	return nodeStart !== null && referenceStart !== null && nodeStart < referenceStart;
+}
+function hasDeclarationBeforeReference(node, name, reference) {
+	if (!node) return false;
+	if (Array.isArray(node)) return node.some((child) => hasDeclarationBeforeReference(child, name, reference));
+	if (!isBeforeReference(node, reference)) return false;
+	if (node.type === "VariableDeclarator") return hasBindingName(node.id, name);
+	if ((node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") && node.id?.name === name) return true;
+	if (node !== reference && isFunction$1(node)) return false;
+	if (node !== reference && (node.type === "ClassDeclaration" || node.type === "ClassExpression")) return false;
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "parent") continue;
+		if (!value || typeof value !== "object") continue;
+		if (hasDeclarationBeforeReference(value, name, reference)) return true;
+	}
+	return false;
+}
+function findDeclarationBeforeReference(node, name, reference) {
+	if (!node) return null;
+	if (Array.isArray(node)) {
+		for (const child of node) {
+			const declaration = findDeclarationBeforeReference(child, name, reference);
+			if (declaration) return declaration;
+		}
+		return null;
+	}
+	if (!isBeforeReference(node, reference)) return null;
+	if (node.type === "VariableDeclarator") return getMatchingBindingIdentifier(node.id, name);
+	if ((node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") && node.id?.name === name) return node.id;
+	if (node !== reference && isFunction$1(node)) return null;
+	if (node !== reference && (node.type === "ClassDeclaration" || node.type === "ClassExpression")) return null;
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "parent") continue;
+		if (!value || typeof value !== "object") continue;
+		const declaration = findDeclarationBeforeReference(value, name, reference);
+		if (declaration) return declaration;
+	}
+	return null;
+}
+function findNearestBindingIdentifier(context, node) {
+	if (node?.type !== "Identifier") return null;
+	const ancestors = context.sourceCode.getAncestors(node);
+	for (const ancestor of ancestors.toReversed()) {
+		if (isFunction$1(ancestor)) for (const param of ancestor.params ?? []) {
+			const binding = getMatchingBindingIdentifier(param, node.name);
+			if (binding) return binding;
+		}
+		if (ancestor.type === "CatchClause") {
+			const binding = getMatchingBindingIdentifier(ancestor.param, node.name);
+			if (binding) return binding;
+		}
+		if (ancestor.type === "BlockStatement" || ancestor.type === "Program") {
+			const binding = findDeclarationBeforeReference(ancestor.body, node.name, node);
+			if (binding) return binding;
+		}
+	}
+	return null;
+}
+function isShadowedIdentifier(context, node) {
+	if (node?.type !== "Identifier") return false;
+	const ancestors = context.sourceCode.getAncestors(node);
+	for (const ancestor of ancestors.toReversed()) {
+		if (isFunction$1(ancestor) && (ancestor.params ?? []).some((param) => hasBindingName(param, node.name))) return true;
+		if (ancestor.type === "CatchClause" && hasBindingName(ancestor.param, node.name)) return true;
+		if ((ancestor.type === "BlockStatement" || ancestor.type === "Program") && hasDeclarationBeforeReference(ancestor.body, node.name, node)) return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/utilities/angular.ts
+function getProgramNode(context, node) {
+	if (node.type === "Program") return node;
+	return context.sourceCode.getAncestors(node).find((ancestor) => ancestor.type === "Program") ?? null;
+}
+function getImportedName(context, node, source) {
+	if (node?.type !== "Identifier") return null;
+	if (isShadowedIdentifier(context, node)) return null;
+	const program = getProgramNode(context, node);
+	for (const statement of program?.body ?? []) {
+		if (statement.type !== "ImportDeclaration" || statement.source?.value !== source) continue;
+		for (const specifier of statement.specifiers ?? []) {
+			if (specifier.type !== "ImportSpecifier" || specifier.local.name !== node.name) continue;
+			return getPropertyName(specifier.imported);
+		}
+	}
+	return null;
+}
+function isNamespaceImport(context, node, source) {
+	if (node?.type !== "Identifier") return false;
+	if (isShadowedIdentifier(context, node)) return false;
+	const program = getProgramNode(context, node);
+	for (const statement of program?.body ?? []) {
+		if (statement.type !== "ImportDeclaration" || statement.source?.value !== source) continue;
+		if ((statement.specifiers ?? []).some((specifier) => specifier.type === "ImportNamespaceSpecifier" && specifier.local.name === node.name)) return true;
+	}
+	return false;
+}
+function isImportedReference(context, node, source, importedNames) {
+	const importedName = getImportedName(context, node, source);
+	return !!importedName && importedNames.has(importedName);
+}
+function isImportedNamespaceMember(context, node, source, memberNames) {
+	return node?.type === "MemberExpression" && node.object?.type === "Identifier" && isNamespaceImport(context, node.object, source) && memberNames.has(getPropertyName(node.property) ?? "");
+}
+function isAngularCoreDecorator(context, decorator, decoratorNames) {
+	if (!decorator) return false;
+	const expression = decorator.expression ?? decorator;
+	const callee = expression?.type === "CallExpression" ? expression.callee : expression;
+	return isImportedReference(context, callee, "@angular/core", decoratorNames) || isImportedNamespaceMember(context, callee, "@angular/core", decoratorNames);
+}
 //#endregion
 //#region src/rules/class-member-order/index.ts
 const ANGULAR_CLASS_DECORATOR_NAMES$1 = new Set([
@@ -45,38 +233,136 @@ const ORDER_LABELS = [
 	"outputs",
 	"everything else"
 ];
-function hasAngularClassDecorator(classNode) {
+function hasAngularClassDecorator(context, classNode) {
 	if (!classNode || !Array.isArray(classNode.decorators)) return false;
-	return classNode.decorators.some((decorator) => ANGULAR_CLASS_DECORATOR_NAMES$1.has(getDecoratorName(decorator) ?? ""));
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, ANGULAR_CLASS_DECORATOR_NAMES$1));
 }
-function getCallName(node) {
-	if (!node || node.type !== "CallExpression") return null;
+function isApiCall(context, node, apiNames) {
+	if (!node || node.type !== "CallExpression") return false;
 	const callee = node.callee;
-	if (callee?.type === "Identifier") return callee.name;
-	if (callee?.type === "MemberExpression") return getPropertyName(callee.property);
-	return null;
-}
-function hasDecorator(element, names) {
-	return Array.isArray(element.decorators) ? element.decorators.some((decorator) => names.has(getDecoratorName(decorator) ?? "")) : false;
+	if (isImportedReference(context, callee, "@angular/core", apiNames)) return true;
+	if (callee?.type !== "MemberExpression") return false;
+	const supportsRequiredApi = [...INPUT_MODEL_CALL_NAMES].some((name) => apiNames.has(name));
+	if (callee.object?.type === "Identifier") {
+		if (getPropertyName(callee.property) === "required") return supportsRequiredApi && isImportedReference(context, callee.object, "@angular/core", apiNames);
+		return isImportedNamespaceMember(context, callee, "@angular/core", apiNames);
+	}
+	if (getPropertyName(callee.property) === "required" && callee.object?.type === "MemberExpression" && callee.object.object?.type === "Identifier") return supportsRequiredApi && isImportedNamespaceMember(context, callee.object, "@angular/core", apiNames) && apiNames.has(getPropertyName(callee.object.property) ?? "");
+	return false;
 }
-function isDirectInjectCall(value) {
-	if (!value || value.type !== "CallExpression") return false;
-	const callee = value.callee;
-	return callee?.type === "Identifier" && callee.name === "inject" || callee?.type === "MemberExpression" && getPropertyName(callee.property) === "inject";
+function hasDecorator(context, element, decoratorNames) {
+	return Array.isArray(element.decorators) ? element.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, decoratorNames)) : false;
 }
-function classifyMember(element) {
+function classifyMember(context, element) {
 	if (CLASS_FIELD_TYPES$1.has(element.type)) {
-		const callName = getCallName(element.value);
-		if (isDirectInjectCall(element.value)) return 0;
-		if (callName && INPUT_MODEL_CALL_NAMES.has(callName)) return 1;
-		if (hasDecorator(element, new Set(["Input"]))) return 1;
-		if (callName && OUTPUT_CALL_NAMES.has(callName)) return 2;
-		if (hasDecorator(element, new Set(["Output"]))) return 2;
+		if (isApiCall(context, element.value, new Set(["inject"]))) return 0;
+		if (isApiCall(context, element.value, INPUT_MODEL_CALL_NAMES)) return 1;
+		if (hasDecorator(context, element, new Set(["Input"]))) return 1;
+		if (isApiCall(context, element.value, OUTPUT_CALL_NAMES)) return 2;
+		if (hasDecorator(context, element, new Set(["Output"]))) return 2;
 		return 3;
 	}
 	if (element.type === "MethodDefinition") return 3;
 	return 3;
 }
+function getMemberName$1(node) {
+	if (!node) return null;
+	if (node.type === "Identifier" || node.type === "PrivateIdentifier") return node.name;
+	return null;
+}
+function collectThisMemberReferences(node, references = /* @__PURE__ */ new Set()) {
+	if (!node) return references;
+	if (Array.isArray(node)) {
+		for (const item of node) collectThisMemberReferences(item, references);
+		return references;
+	}
+	if (node.type === "MemberExpression" && node.object?.type === "ThisExpression") {
+		const propertyName = getPropertyName(node.property);
+		if (propertyName) references.add(propertyName);
+	}
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "parent") continue;
+		if (!value || typeof value !== "object") continue;
+		collectThisMemberReferences(value, references);
+	}
+	return references;
+}
+function applyDependencyGroups(classifiedMembers) {
+	const membersByName = /* @__PURE__ */ new Map();
+	for (const member of classifiedMembers) if (member.name) membersByName.set(member.name, member);
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const member of classifiedMembers) for (const dependencyName of member.dependencies) {
+			const dependency = membersByName.get(dependencyName);
+			if (!dependency) continue;
+			if (dependency.effectiveGroup <= member.effectiveGroup) continue;
+			dependency.effectiveGroup = member.effectiveGroup;
+			changed = true;
+		}
+	}
+}
+function dependsOn(member, dependency, membersByName, seen = /* @__PURE__ */ new Set()) {
+	if (!dependency.name) return false;
+	if (member.dependencies.has(dependency.name)) return true;
+	if (seen.has(member)) return false;
+	seen.add(member);
+	for (const dependencyName of member.dependencies) {
+		const next = membersByName.get(dependencyName);
+		if (next && dependsOn(next, dependency, membersByName, seen)) return true;
+	}
+	return false;
+}
+function getSortedMembers(classifiedMembers) {
+	const membersByName = /* @__PURE__ */ new Map();
+	for (const member of classifiedMembers) if (member.name) membersByName.set(member.name, member);
+	return classifiedMembers.toSorted((left, right) => {
+		if (dependsOn(left, right, membersByName)) return 1;
+		if (dependsOn(right, left, membersByName)) return -1;
+		return left.effectiveGroup - right.effectiveGroup;
+	});
+}
+function hasUnresolvedPrioritizedDependency(member, membersByName) {
+	if (member.group === 3) return false;
+	for (const dependencyName of member.dependencies) if (!membersByName.has(dependencyName)) return true;
+	return false;
+}
+function getSortedMembersFix(context, classBody, classifiedMembers) {
+	if (!classifiedMembers.length) return void 0;
+	if ((classBody.body ?? []).length !== classifiedMembers.length) return void 0;
+	const sortableRanges = [];
+	const membersByName = /* @__PURE__ */ new Map();
+	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 (element.type === "AccessorProperty") return void 0;
+		if (element.computed) return void 0;
+		if (Array.isArray(element.decorators) && element.decorators.length > 0) return void 0;
+		if (hasUnresolvedPrioritizedDependency(member, membersByName)) return;
+		const range = getRange(element);
+		if (!range) return void 0;
+		if (!context.sourceCode.text.slice(range[0], range[1]).trimEnd().endsWith(";")) return;
+		sortableRanges.push(range);
+	}
+	const sortedMembers = getSortedMembers(classifiedMembers);
+	if (sortedMembers.every((member, index) => member.element === classifiedMembers[index]?.element)) return void 0;
+	return (fixer) => {
+		const sourceText = context.sourceCode.text;
+		const sortedTexts = sortedMembers.map(({ element }) => {
+			const range = getRange(element);
+			return range ? sourceText.slice(range[0], range[1]) : "";
+		});
+		let output = "";
+		for (let index = 0; index < sortableRanges.length; index += 1) {
+			const [, end] = sortableRanges[index];
+			const nextStart = sortableRanges[index + 1]?.[0];
+			output += sortedTexts[index];
+			output += sourceText.slice(end, nextStart ?? end);
+		}
+		return fixer.replaceTextRange([sortableRanges[0][0], sortableRanges.at(-1)[1]], output);
+	};
+}
 const classMemberOrder = defineRule({
 	meta: {
 		type: "suggestion",
@@ -84,29 +370,51 @@ const classMemberOrder = defineRule({
 			description: "Require Angular class members to be ordered as inject fields, inputs/models, outputs, then everything else.",
 			recommended: true
 		},
+		fixable: "code",
 		schema: [],
 		messages: { outOfOrder: "Angular class member should be ordered before {{previousGroup}} and with {{expectedGroup}}." }
 	},
 	createOnce(context) {
 		return { ClassBody(node) {
-			if (!hasAngularClassDecorator(node.parent)) return;
+			const classBody = node;
+			if (!hasAngularClassDecorator(context, classBody.parent)) return;
 			let highestSeen = null;
-			for (const element of node.body ?? []) {
-				const group = classifyMember(element);
+			const classifiedMembers = [];
+			const outOfOrderReports = [];
+			for (const element of classBody.body ?? []) {
+				const group = classifyMember(context, element);
 				if (group === null) continue;
-				if (highestSeen !== null && group < highestSeen) {
-					context.report({
-						node: element,
-						messageId: "outOfOrder",
-						data: {
-							expectedGroup: ORDER_LABELS[group],
-							previousGroup: ORDER_LABELS[highestSeen]
-						}
+				classifiedMembers.push({
+					element,
+					group,
+					effectiveGroup: group,
+					name: getMemberName$1(element.key),
+					dependencies: collectThisMemberReferences(element.value)
+				});
+			}
+			applyDependencyGroups(classifiedMembers);
+			for (const { element, effectiveGroup } of classifiedMembers) {
+				if (highestSeen !== null && effectiveGroup < highestSeen) {
+					outOfOrderReports.push({
+						element,
+						effectiveGroup,
+						previousEffectiveGroup: highestSeen
 					});
 					continue;
 				}
-				highestSeen = group;
+				highestSeen = effectiveGroup;
 			}
+			if (!outOfOrderReports.length) return;
+			const fix = getSortedMembersFix(context, classBody, classifiedMembers);
+			for (const [index, report] of outOfOrderReports.entries()) context.report({
+				node: report.element,
+				messageId: "outOfOrder",
+				data: {
+					expectedGroup: ORDER_LABELS[report.effectiveGroup],
+					previousGroup: ORDER_LABELS[report.previousEffectiveGroup]
+				},
+				fix: index === 0 ? fix : void 0
+			});
 		} };
 	}
 });
@@ -115,25 +423,22 @@ const classMemberOrder = defineRule({
 const DEFAULT_DISALLOW_INJECT_INJECTOR = true;
 const DEFAULT_DISALLOW_RUN_IN_INJECTION_CONTEXT = true;
 const RUN_IN_INJECTION_CONTEXT_NAMES = new Set(["runInInjectionContext", "runInContext"]);
-function isAngularNamespaceMember(node, namespaces, memberName) {
-	return node?.type === "MemberExpression" && node.object?.type === "Identifier" && namespaces.has(node.object.name) && getPropertyName(node.property) === memberName;
-}
-function isInjectCall(callNode, injectNames, angularNamespaces) {
+const INJECT_NAMES = new Set(["inject"]);
+const INJECTOR_NAMES = new Set(["Injector"]);
+function isInjectCall(context, callNode) {
 	const callee = callNode.callee;
-	return callee?.type === "Identifier" && injectNames.has(callee.name) || isAngularNamespaceMember(callee, angularNamespaces, "inject");
+	return isImportedReference(context, callee, "@angular/core", INJECT_NAMES) || isImportedNamespaceMember(context, callee, "@angular/core", INJECT_NAMES);
 }
-function isInjectorReference(node, injectorNames, angularNamespaces) {
-	return node?.type === "Identifier" && injectorNames.has(node.name) || isAngularNamespaceMember(node, angularNamespaces, "Injector");
+function isInjectorReference(context, node) {
+	return isImportedReference(context, node, "@angular/core", INJECTOR_NAMES) || isImportedNamespaceMember(context, node, "@angular/core", INJECTOR_NAMES);
 }
-function isDisallowedInjectInjector(callNode, injectNames, injectorNames, angularNamespaces) {
-	if (!isInjectCall(callNode, injectNames, angularNamespaces)) return false;
-	return isInjectorReference(callNode.arguments?.[0], injectorNames, angularNamespaces);
+function isDisallowedInjectInjector(context, callNode) {
+	if (!isInjectCall(context, callNode)) return false;
+	return isInjectorReference(context, callNode.arguments?.[0]);
 }
-function isDisallowedRunInInjectionContext(callNode, runInInjectionContextNames, runInContextNames, angularNamespaces) {
+function isDisallowedRunInInjectionContext(context, callNode) {
 	const callee = callNode.callee;
-	if (callee?.type === "Identifier") return runInInjectionContextNames.has(callee.name) || runInContextNames.has(callee.name);
-	if (callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && angularNamespaces.has(callee.object.name)) return RUN_IN_INJECTION_CONTEXT_NAMES.has(getPropertyName(callee.property) ?? "");
-	return false;
+	return isImportedReference(context, callee, "@angular/core", RUN_IN_INJECTION_CONTEXT_NAMES) || isImportedNamespaceMember(context, callee, "@angular/core", RUN_IN_INJECTION_CONTEXT_NAMES);
 }
 const avoidExplicitInjectionContext = defineRule({
 	meta: {
@@ -162,44 +467,378 @@ const avoidExplicitInjectionContext = defineRule({
 		}
 	},
 	createOnce(context) {
-		const injectNames = /* @__PURE__ */ new Set();
-		const injectorNames = /* @__PURE__ */ new Set();
-		const runInInjectionContextNames = /* @__PURE__ */ new Set();
-		const runInContextNames = /* @__PURE__ */ new Set();
-		const angularNamespaces = /* @__PURE__ */ new Set();
+		return { CallExpression(node) {
+			const callNode = node;
+			const options = context.options[0] ?? {};
+			const disallowInjectInjector = options.disallowInjectInjector ?? DEFAULT_DISALLOW_INJECT_INJECTOR;
+			const disallowRunInInjectionContext = options.disallowRunInInjectionContext ?? DEFAULT_DISALLOW_RUN_IN_INJECTION_CONTEXT;
+			if (disallowInjectInjector && isDisallowedInjectInjector(context, callNode)) context.report({
+				node: callNode.callee,
+				messageId: "avoidInjectInjector"
+			});
+			if (disallowRunInInjectionContext && isDisallowedRunInInjectionContext(context, callNode)) context.report({
+				node: callNode.callee,
+				messageId: "avoidRunInInjectionContext"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/avoid-explicit-subscription-management/index.ts
+const TARGET_DECORATORS$2 = new Set([
+	"Component",
+	"Directive",
+	"Injectable"
+]);
+const FIELD_NODE_TYPES$2 = new Set([
+	"AccessorProperty",
+	"FieldDefinition",
+	"PropertyDefinition"
+]);
+const RXJS_SUBSCRIBABLE_NAMES = new Set([
+	"AsyncSubject",
+	"BehaviorSubject",
+	"Observable",
+	"ReplaySubject",
+	"Subject"
+]);
+function hasTargetDecorator$3(context, classNode) {
+	if (!classNode || !Array.isArray(classNode.decorators)) return false;
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, TARGET_DECORATORS$2));
+}
+function hasSubscriptionTypeReference(context, node, subscriptionLocalNames, rxjsNamespaces) {
+	if (!node) return false;
+	if (node.type === "TSTypeReference") {
+		const typeName = getTypeName(node.typeName);
+		if (node.typeName?.type === "Identifier" && typeName && subscriptionLocalNames.has(typeName) && !isShadowedIdentifier(context, node.typeName)) return true;
+		if (typeName?.includes(".")) {
+			const [namespaceName, memberName] = typeName.split(".");
+			return memberName === "Subscription" && rxjsNamespaces.has(namespaceName);
+		}
+	}
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "parent") continue;
+		if (!value || typeof value !== "object") continue;
+		if (Array.isArray(value)) {
+			if (value.some((child) => hasSubscriptionTypeReference(context, child, subscriptionLocalNames, rxjsNamespaces))) return true;
+			continue;
+		}
+		if (hasSubscriptionTypeReference(context, value, subscriptionLocalNames, rxjsNamespaces)) return true;
+	}
+	return false;
+}
+function isSubscriptionConstructor(context, node, subscriptionLocalNames, rxjsNamespaces) {
+	const expression = unwrapExpression(node);
+	if (expression?.type !== "NewExpression") return false;
+	const callee = unwrapExpression(expression.callee);
+	if (callee?.type === "Identifier") return subscriptionLocalNames.has(callee.name) && !isShadowedIdentifier(context, callee);
+	if (callee?.type !== "MemberExpression") return false;
+	return callee.object?.type === "Identifier" && rxjsNamespaces.has(callee.object.name) && !isShadowedIdentifier(context, callee.object) && getPropertyName(callee.property) === "Subscription";
+}
+function getReferenceName(node) {
+	const expression = unwrapExpression(node);
+	if (!expression) return null;
+	if (expression.type === "Identifier") return expression.name;
+	if (expression.type !== "MemberExpression") return null;
+	if (expression.object?.type !== "ThisExpression") return null;
+	return getPropertyName(expression.property);
+}
+function isObservableReferenceName(name) {
+	return name.length > 1 && name.endsWith("$");
+}
+function addTrackedReference(references, name, binding) {
+	const bindings = references.get(name) ?? /* @__PURE__ */ new Set();
+	if (binding) bindings.add(binding);
+	references.set(name, bindings);
+}
+function hasTrackedReferenceName(references, name) {
+	return references.has(name);
+}
+function isTrackedReferenceExpression(context, node, references) {
+	const expression = unwrapExpression(node);
+	if (!expression) return false;
+	const referenceName = getReferenceName(expression);
+	if (!referenceName) return false;
+	const bindings = references.get(referenceName);
+	if (!bindings) return false;
+	if (expression.type === "MemberExpression" && expression.object?.type === "ThisExpression") return true;
+	if (expression.type !== "Identifier") return false;
+	const nearestBinding = findNearestBindingIdentifier(context, expression);
+	return !!nearestBinding && bindings.has(nearestBinding);
+}
+function getDeclaredName(node) {
+	if (!node) return null;
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "PrivateIdentifier") return node.name;
+	return null;
+}
+function hasRxjsSubscribableTypeReference(context, node, rxjsSubscribableLocalNames, rxjsNamespaces) {
+	if (!node) return false;
+	if (node.type === "TSTypeReference") {
+		const typeName = getTypeName(node.typeName);
+		if (node.typeName?.type === "Identifier" && typeName && rxjsSubscribableLocalNames.has(typeName) && !isShadowedIdentifier(context, node.typeName)) return true;
+		if (typeName?.includes(".")) {
+			const [namespaceName, memberName] = typeName.split(".");
+			return RXJS_SUBSCRIBABLE_NAMES.has(memberName) && rxjsNamespaces.has(namespaceName);
+		}
+	}
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "parent") continue;
+		if (!value || typeof value !== "object") continue;
+		if (Array.isArray(value)) {
+			if (value.some((child) => hasRxjsSubscribableTypeReference(context, child, rxjsSubscribableLocalNames, rxjsNamespaces))) return true;
+			continue;
+		}
+		if (hasRxjsSubscribableTypeReference(context, value, rxjsSubscribableLocalNames, rxjsNamespaces)) return true;
+	}
+	return false;
+}
+function isRxjsSubscribableConstructor(context, node, rxjsSubscribableLocalNames, rxjsNamespaces) {
+	const expression = unwrapExpression(node);
+	if (expression?.type !== "NewExpression") return false;
+	const callee = unwrapExpression(expression.callee);
+	if (callee?.type === "Identifier") return rxjsSubscribableLocalNames.has(callee.name) && !isShadowedIdentifier(context, callee);
+	if (callee?.type !== "MemberExpression") return false;
+	return callee.object?.type === "Identifier" && rxjsNamespaces.has(callee.object.name) && !isShadowedIdentifier(context, callee.object) && RXJS_SUBSCRIBABLE_NAMES.has(getPropertyName(callee.property) ?? "");
+}
+function isTakeUntilDestroyedCall(node, takeUntilDestroyedLocalNames, interopNamespaces) {
+	const callNode = unwrapExpression(node);
+	if (callNode?.type !== "CallExpression") return false;
+	const callee = unwrapExpression(callNode.callee);
+	if (callee?.type === "Identifier") return takeUntilDestroyedLocalNames.has(callee.name);
+	if (callee?.type !== "MemberExpression") return false;
+	return callee.object?.type === "Identifier" && interopNamespaces.has(callee.object.name) && getPropertyName(callee.property) === "takeUntilDestroyed";
+}
+function isTakeUntilDestroyedSubscribe(node, takeUntilDestroyedLocalNames, interopNamespaces) {
+	const callNode = unwrapExpression(node);
+	if (callNode?.type !== "CallExpression") return false;
+	const callee = unwrapExpression(callNode.callee);
+	if (callee?.type !== "MemberExpression") return false;
+	if (getPropertyName(callee.property) !== "subscribe") return false;
+	const source = unwrapExpression(callee.object);
+	if (source?.type !== "CallExpression") return false;
+	const sourceCallee = unwrapExpression(source.callee);
+	if (sourceCallee?.type !== "MemberExpression") return false;
+	if (getPropertyName(sourceCallee.property) !== "pipe") return false;
+	return (source.arguments ?? []).some((argument) => isTakeUntilDestroyedCall(argument, takeUntilDestroyedLocalNames, interopNamespaces));
+}
+function isKnownRxjsSubscribableExpression(context, node, rxjsSubscribableReferences, rxjsSubscribableLocalNames, rxjsNamespaces) {
+	const expression = unwrapExpression(node);
+	if (!expression) return false;
+	const referenceName = getReferenceName(expression);
+	if (referenceName && isObservableReferenceName(referenceName)) return true;
+	if (isTrackedReferenceExpression(context, expression, rxjsSubscribableReferences)) return true;
+	if (isRxjsSubscribableConstructor(context, expression, rxjsSubscribableLocalNames, rxjsNamespaces)) return true;
+	if (expression.type !== "CallExpression") return false;
+	const callee = unwrapExpression(expression.callee);
+	if (callee?.type !== "MemberExpression") return false;
+	const methodName = getPropertyName(callee.property);
+	if (methodName !== "asObservable" && methodName !== "pipe") return false;
+	return isKnownRxjsSubscribableExpression(context, callee.object, rxjsSubscribableReferences, rxjsSubscribableLocalNames, rxjsNamespaces);
+}
+function isUnmanagedSubscribeCall(context, node, rxjsSubscribableReferences, rxjsSubscribableLocalNames, rxjsNamespaces, takeUntilDestroyedLocalNames, interopNamespaces) {
+	const callNode = unwrapExpression(node);
+	if (callNode?.type !== "CallExpression") return false;
+	const callee = unwrapExpression(callNode.callee);
+	if (callee?.type !== "MemberExpression") return false;
+	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) {
+	if (!node) return;
+	if (Array.isArray(node)) {
+		for (const child of node) walkNode$1(child, containingClass, visitor);
+		return;
+	}
+	if (node !== containingClass && (node.type === "ClassDeclaration" || node.type === "ClassExpression")) return;
+	if (visitor(node) === false) return;
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "parent") continue;
+		if (!value || typeof value !== "object") continue;
+		walkNode$1(value, containingClass, visitor);
+	}
+}
+function containsUnmanagedSubscribeCall(context, node, containingClass, rxjsSubscribableReferences, rxjsSubscribableLocalNames, rxjsNamespaces, takeUntilDestroyedLocalNames, interopNamespaces) {
+	let found = false;
+	walkNode$1(node, containingClass, (current) => {
+		if (isUnmanagedSubscribeCall(context, current, rxjsSubscribableReferences, rxjsSubscribableLocalNames, rxjsNamespaces, takeUntilDestroyedLocalNames, interopNamespaces)) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
+}
+function collectRxjsSubscribableReferences(context, classBody, classNode, rxjsSubscribableLocalNames, rxjsNamespaces) {
+	const references = /* @__PURE__ */ new Map();
+	let changed = true;
+	while (changed) {
+		changed = false;
+		walkNode$1(classBody, classNode, (node) => {
+			if (FIELD_NODE_TYPES$2.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)) {
+					addTrackedReference(references, name, node.key);
+					changed = true;
+				}
+				return;
+			}
+			if (node.type === "VariableDeclarator" && node.id?.type === "Identifier") {
+				if (hasTrackedReferenceName(references, node.id.name)) return;
+				if (isObservableReferenceName(node.id.name) || hasRxjsSubscribableTypeReference(context, node.id.typeAnnotation?.typeAnnotation, rxjsSubscribableLocalNames, rxjsNamespaces) || isRxjsSubscribableConstructor(context, node.init, rxjsSubscribableLocalNames, rxjsNamespaces) || isKnownRxjsSubscribableExpression(context, node.init, references, rxjsSubscribableLocalNames, rxjsNamespaces)) {
+					addTrackedReference(references, node.id.name, node.id);
+					changed = true;
+				}
+				return;
+			}
+			if (node.type === "AssignmentExpression") {
+				const name = getReferenceName(node.left);
+				if (!name || hasTrackedReferenceName(references, name)) return;
+				if (isObservableReferenceName(name) || isRxjsSubscribableConstructor(context, node.right, rxjsSubscribableLocalNames, rxjsNamespaces) || isKnownRxjsSubscribableExpression(context, node.right, references, rxjsSubscribableLocalNames, rxjsNamespaces)) {
+					addTrackedReference(references, name, findNearestBindingIdentifier(context, node.left));
+					changed = true;
+				}
+			}
+		});
+	}
+	return references;
+}
+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)) {
+			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);
+			return;
+		}
+		if (node.type === "VariableDeclarator" && node.id?.type === "Identifier") {
+			if (hasSubscriptionTypeReference(context, node.id.typeAnnotation?.typeAnnotation, subscriptionLocalNames, rxjsNamespaces) || isSubscriptionConstructor(context, node.init, subscriptionLocalNames, rxjsNamespaces) || isUnmanagedSubscribeCall(context, node.init, rxjsSubscribableReferences, rxjsSubscribableLocalNames, rxjsNamespaces, takeUntilDestroyedLocalNames, interopNamespaces)) addTrackedReference(references, node.id.name, node.id);
+			return;
+		}
+		if (node.type === "AssignmentExpression") {
+			const name = getReferenceName(node.left);
+			if (!name) return;
+			if (isSubscriptionConstructor(context, node.right, subscriptionLocalNames, rxjsNamespaces) || isUnmanagedSubscribeCall(context, node.right, rxjsSubscribableReferences, rxjsSubscribableLocalNames, rxjsNamespaces, takeUntilDestroyedLocalNames, interopNamespaces)) addTrackedReference(references, name, findNearestBindingIdentifier(context, node.left));
+		}
+	});
+	return references;
+}
+function isSubscriptionAddCall(context, node, containingClass, subscriptionReferences, rxjsSubscribableReferences, rxjsSubscribableLocalNames, rxjsNamespaces, takeUntilDestroyedLocalNames, interopNamespaces) {
+	const callNode = unwrapExpression(node);
+	if (callNode?.type !== "CallExpression") return false;
+	const callee = unwrapExpression(callNode.callee);
+	if (callee?.type !== "MemberExpression") return false;
+	if (getPropertyName(callee.property) !== "add") return false;
+	if (isTrackedReferenceExpression(context, callee.object, subscriptionReferences)) return true;
+	return (callNode.arguments ?? []).some((argument) => isTrackedReferenceExpression(context, argument, subscriptionReferences) || containsUnmanagedSubscribeCall(context, argument, containingClass, rxjsSubscribableReferences, rxjsSubscribableLocalNames, rxjsNamespaces, takeUntilDestroyedLocalNames, interopNamespaces));
+}
+function isSubscriptionUnsubscribeCall(context, node, subscriptionReferences) {
+	const callNode = unwrapExpression(node);
+	if (callNode?.type !== "CallExpression") return false;
+	const callee = unwrapExpression(callNode.callee);
+	if (callee?.type !== "MemberExpression") return false;
+	if (getPropertyName(callee.property) !== "unsubscribe") return false;
+	return isTrackedReferenceExpression(context, callee.object, subscriptionReferences);
+}
+const avoidExplicitSubscriptionManagement = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Avoid manual RxJS Subscription lifecycle management in Angular components, directives, and services.",
+			recommended: true
+		},
+		schema: [],
+		messages: {
+			explicitSubscriptionType: "Avoid storing RxJS Subscription references in Angular classes. Prefer takeUntilDestroyed, toSignal, or firstValueFrom.",
+			explicitSubscriptionConstructor: "Avoid creating RxJS Subscription instances in Angular classes. Prefer takeUntilDestroyed, toSignal, or firstValueFrom.",
+			explicitSubscribe: "Avoid subscribe() calls that require manual lifecycle management. Prefer takeUntilDestroyed, toSignal, or firstValueFrom.",
+			explicitSubscriptionAdd: "Avoid adding subscriptions to a Subscription container. Prefer takeUntilDestroyed, toSignal, or firstValueFrom.",
+			explicitUnsubscribe: "Avoid manual unsubscribe() calls in Angular classes. Prefer takeUntilDestroyed, toSignal, or firstValueFrom."
+		}
+	},
+	createOnce(context) {
+		const subscriptionLocalNames = /* @__PURE__ */ new Set();
+		const rxjsSubscribableLocalNames = /* @__PURE__ */ new Set();
+		const rxjsNamespaces = /* @__PURE__ */ new Set();
+		const takeUntilDestroyedLocalNames = /* @__PURE__ */ new Set();
+		const interopNamespaces = /* @__PURE__ */ new Set();
 		return {
 			before() {
-				injectNames.clear();
-				injectorNames.clear();
-				runInInjectionContextNames.clear();
-				runInContextNames.clear();
-				angularNamespaces.clear();
+				subscriptionLocalNames.clear();
+				rxjsSubscribableLocalNames.clear();
+				rxjsNamespaces.clear();
+				takeUntilDestroyedLocalNames.clear();
+				interopNamespaces.clear();
 			},
 			ImportDeclaration(node) {
-				if (node.source?.value !== "@angular/core") return;
-				for (const specifier of node.specifiers ?? []) {
+				const source = node.source?.value;
+				if (source === "rxjs") for (const specifier of node.specifiers ?? []) {
 					if (specifier.type === "ImportSpecifier") {
 						const importedName = getPropertyName(specifier.imported);
-						if (importedName === "inject") injectNames.add(specifier.local.name);
-						if (importedName === "Injector") injectorNames.add(specifier.local.name);
-						if (importedName === "runInInjectionContext") runInInjectionContextNames.add(specifier.local.name);
-						if (importedName === "runInContext") runInContextNames.add(specifier.local.name);
+						if (importedName === "Subscription") subscriptionLocalNames.add(specifier.local.name);
+						if (RXJS_SUBSCRIBABLE_NAMES.has(importedName ?? "")) rxjsSubscribableLocalNames.add(specifier.local.name);
+						continue;
+					}
+					if (specifier.type === "ImportNamespaceSpecifier") rxjsNamespaces.add(specifier.local.name);
+				}
+				if (source === "@angular/core/rxjs-interop") for (const specifier of node.specifiers ?? []) {
+					if (specifier.type === "ImportSpecifier") {
+						if (getPropertyName(specifier.imported) === "takeUntilDestroyed") takeUntilDestroyedLocalNames.add(specifier.local.name);
+						continue;
 					}
-					if (specifier.type === "ImportNamespaceSpecifier") angularNamespaces.add(specifier.local.name);
+					if (specifier.type === "ImportNamespaceSpecifier") interopNamespaces.add(specifier.local.name);
 				}
 			},
-			CallExpression(node) {
-				const callNode = node;
-				const options = context.options[0] ?? {};
-				const disallowInjectInjector = options.disallowInjectInjector ?? DEFAULT_DISALLOW_INJECT_INJECTOR;
-				const disallowRunInInjectionContext = options.disallowRunInInjectionContext ?? DEFAULT_DISALLOW_RUN_IN_INJECTION_CONTEXT;
-				if (disallowInjectInjector && isDisallowedInjectInjector(callNode, injectNames, injectorNames, angularNamespaces)) context.report({
-					node: callNode.callee,
-					messageId: "avoidInjectInjector"
-				});
-				if (disallowRunInInjectionContext && isDisallowedRunInInjectionContext(callNode, runInInjectionContextNames, runInContextNames, angularNamespaces)) context.report({
-					node: callNode.callee,
-					messageId: "avoidRunInInjectionContext"
+			ClassBody(node) {
+				const classBody = node;
+				const classNode = classBody.parent;
+				if (!classNode || !hasTargetDecorator$3(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)) {
+						if (hasSubscriptionTypeReference(context, current.typeAnnotation?.typeAnnotation, subscriptionLocalNames, rxjsNamespaces)) context.report({
+							node: current.key ?? current,
+							messageId: "explicitSubscriptionType"
+						});
+						return;
+					}
+					if (current.type === "VariableDeclarator" && current.id?.type === "Identifier" && hasSubscriptionTypeReference(context, current.id.typeAnnotation?.typeAnnotation, subscriptionLocalNames, rxjsNamespaces)) {
+						context.report({
+							node: current.id,
+							messageId: "explicitSubscriptionType"
+						});
+						return;
+					}
+					if (isSubscriptionConstructor(context, current, subscriptionLocalNames, rxjsNamespaces)) {
+						context.report({
+							node: current,
+							messageId: "explicitSubscriptionConstructor"
+						});
+						return false;
+					}
+					if (isSubscriptionAddCall(context, current, classNode, subscriptionReferences, rxjsSubscribableReferences, rxjsSubscribableLocalNames, rxjsNamespaces, takeUntilDestroyedLocalNames, interopNamespaces)) {
+						context.report({
+							node: current,
+							messageId: "explicitSubscriptionAdd"
+						});
+						return false;
+					}
+					if (isSubscriptionUnsubscribeCall(context, current, subscriptionReferences)) {
+						context.report({
+							node: current,
+							messageId: "explicitUnsubscribe"
+						});
+						return false;
+					}
+					if (isUnmanagedSubscribeCall(context, current, rxjsSubscribableReferences, rxjsSubscribableLocalNames, rxjsNamespaces, takeUntilDestroyedLocalNames, interopNamespaces)) {
+						context.report({
+							node: current,
+							messageId: "explicitSubscribe"
+						});
+						return false;
+					}
 				});
 			}
 		};
@@ -210,9 +849,15 @@ const avoidExplicitInjectionContext = defineRule({
 const DEFAULT_ALLOW_FOR_GROUPING = true;
 const DEFAULT_ALLOW_FOR_PROVIDING = false;
 const DEFAULT_ALLOW_FOR_ROUTING = false;
-function getNgModuleMetadata(node) {
-	if (node.type !== "Decorator") return null;
-	if (getDecoratorName(node) !== "NgModule") return null;
+function isNgModuleDecorator(context, node) {
+	if (node.type !== "Decorator") return false;
+	const expression = node.expression ?? node;
+	const callee = expression?.type === "CallExpression" ? expression.callee : expression;
+	if (callee?.type === "Identifier") return getImportedName(context, callee, "@angular/core") === "NgModule";
+	return callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && isNamespaceImport(context, callee.object, "@angular/core") && getPropertyName(callee.property) === "NgModule";
+}
+function getNgModuleMetadata(context, node) {
+	if (!isNgModuleDecorator(context, node)) return null;
 	const expression = node.expression;
 	if (expression?.type !== "CallExpression") return null;
 	const metadata = expression.arguments?.[0];
@@ -226,8 +871,16 @@ function getArrayElementsFromProperty(metadata, propertyName) {
 function isMemberCall(node, methodName) {
 	return node.type === "CallExpression" && getPropertyName(node.callee?.property) === methodName;
 }
-function isRouterModuleForChild(node) {
-	return isMemberCall(node, "forChild") && node.callee?.type === "MemberExpression" && getPropertyName(node.callee.object) === "RouterModule";
+function isModuleCallFromImport(context, node, expectedSource, expectedModuleName) {
+	if (node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	if (callee?.type !== "MemberExpression") return false;
+	const moduleRef = callee.object;
+	if (moduleRef?.type === "Identifier") return getImportedName(context, moduleRef, expectedSource) === expectedModuleName;
+	if (moduleRef?.type !== "MemberExpression") return false;
+	if (moduleRef.object?.type !== "Identifier") return false;
+	if (!isNamespaceImport(context, moduleRef.object, expectedSource)) return false;
+	return getPropertyName(moduleRef.property) === expectedModuleName;
 }
 function getNgModuleClassNode(decoratorNode) {
 	const parent = decoratorNode.parent;
@@ -264,45 +917,279 @@ const avoidNgModules = defineRule({
 			}
 		}],
 		messages: {
-			avoidModuleImportsExports: "NgModule imports/exports are legacy composition. Prefer using standalone things directly.",
-			avoidForRoot: "Avoid module.forRoot(...). Prefer provideX(...) functions to register injection providers.",
-			avoidRouterForChild: "Avoid RouterModule.forChild(routes). Prefer provideRouter(...) and lazy route entries such as loadComponent: () => import('./components/auth/login-page')."
+			avoidModuleImportsExports: "NgModule imports/exports are legacy composition. Prefer using standalone things directly.",
+			avoidForRoot: "Avoid module.forRoot(...). Prefer provideX(...) functions to register injection providers.",
+			avoidRouterForRoot: "Avoid RouterModule.forRoot(routes). Prefer provideRouter(routes). See https://angular.dev/guide/routing/define-routes",
+			avoidRouterForChild: "Avoid RouterModule.forChild(routes). Prefer provideRouter(...) and lazy route entries such as loadComponent: () => import('./components/auth/login-page').",
+			avoidNgrxStoreForRoot: "Avoid StoreModule.forRoot(...). Prefer provideStore(...) with standalone providers. See https://ngrx.io/guide/store",
+			avoidNgrxEffectsForRoot: "Avoid EffectsModule.forRoot(...). Prefer provideEffects(...) with standalone providers. See https://ngrx.io/guide/effects",
+			avoidNgrxStoreForFeature: "Avoid StoreModule.forFeature(...). Prefer provideState(...) with standalone providers. See https://ngrx.io/guide/store",
+			avoidNgrxEffectsForFeature: "Avoid EffectsModule.forFeature(...). Prefer provideEffects(...) scoped to feature providers. See https://ngrx.io/guide/effects",
+			avoidNgrxStoreDevtoolsInstrument: "Avoid StoreDevtoolsModule.instrument(...). Prefer provideStoreDevtools(...) with standalone providers. See https://ngrx.io/guide/store-devtools",
+			avoidNgrxRouterStoreForRoot: "Avoid StoreRouterConnectingModule.forRoot(...). Prefer provideRouterStore(...) with standalone providers. See https://ngrx.io/guide/router-store"
+		}
+	},
+	createOnce(context) {
+		return { Decorator(node) {
+			const options = context.options[0] ?? {};
+			const allowForGrouping = options.allowForGrouping ?? DEFAULT_ALLOW_FOR_GROUPING;
+			const allowForProviding = options.allowForProviding ?? DEFAULT_ALLOW_FOR_PROVIDING;
+			const allowForRouting = options.allowForRouting ?? DEFAULT_ALLOW_FOR_ROUTING;
+			const metadata = getNgModuleMetadata(context, node);
+			if (!metadata) return;
+			const importsElements = getArrayElementsFromProperty(metadata, "imports");
+			const exportsElements = getArrayElementsFromProperty(metadata, "exports");
+			if (!allowForGrouping && (importsElements.length > 0 || exportsElements.length > 0)) context.report({
+				node,
+				messageId: "avoidModuleImportsExports"
+			});
+			const importCalls = importsElements.filter((element) => element.type === "CallExpression");
+			if (!allowForProviding) {
+				for (const call of importCalls) {
+					const methodName = getPropertyName(call.callee?.property);
+					if (methodName === "forRoot" && isModuleCallFromImport(context, call, "@angular/router", "RouterModule") && !allowForRouting) {
+						context.report({
+							node: call,
+							messageId: "avoidRouterForRoot"
+						});
+						continue;
+					}
+					if (methodName === "forRoot" && isModuleCallFromImport(context, call, "@ngrx/store", "StoreModule")) {
+						context.report({
+							node: call,
+							messageId: "avoidNgrxStoreForRoot"
+						});
+						continue;
+					}
+					if (methodName === "forRoot" && isModuleCallFromImport(context, call, "@ngrx/effects", "EffectsModule")) {
+						context.report({
+							node: call,
+							messageId: "avoidNgrxEffectsForRoot"
+						});
+						continue;
+					}
+					if (methodName === "forFeature" && isModuleCallFromImport(context, call, "@ngrx/store", "StoreModule")) {
+						context.report({
+							node: call,
+							messageId: "avoidNgrxStoreForFeature"
+						});
+						continue;
+					}
+					if (methodName === "forFeature" && isModuleCallFromImport(context, call, "@ngrx/effects", "EffectsModule")) {
+						context.report({
+							node: call,
+							messageId: "avoidNgrxEffectsForFeature"
+						});
+						continue;
+					}
+					if (methodName === "instrument" && isModuleCallFromImport(context, call, "@ngrx/store-devtools", "StoreDevtoolsModule")) {
+						context.report({
+							node: call,
+							messageId: "avoidNgrxStoreDevtoolsInstrument"
+						});
+						continue;
+					}
+					if (methodName === "forRoot" && isModuleCallFromImport(context, call, "@ngrx/router-store", "StoreRouterConnectingModule")) {
+						context.report({
+							node: call,
+							messageId: "avoidNgrxRouterStoreForRoot"
+						});
+						continue;
+					}
+					if (methodName === "forRoot" && isModuleCallFromImport(context, call, "@angular/router", "RouterModule") && allowForRouting) continue;
+					if (!isMemberCall(call, "forRoot")) continue;
+					context.report({
+						node: call,
+						messageId: "avoidForRoot"
+					});
+				}
+				const staticForRootMethod = getStaticForRootMethod(getNgModuleClassNode(node));
+				if (staticForRootMethod) context.report({
+					node: staticForRootMethod.key ?? staticForRootMethod,
+					messageId: "avoidForRoot"
+				});
+			}
+			if (!allowForRouting) for (const call of importCalls) {
+				if (!isMemberCall(call, "forChild")) continue;
+				if (!isModuleCallFromImport(context, call, "@angular/router", "RouterModule")) continue;
+				context.report({
+					node: call,
+					messageId: "avoidRouterForChild"
+				});
+			}
+		} };
+	}
+});
+//#endregion
+//#region src/rules/avoid-rxjs-state-in-component/index.ts
+const TARGET_DECORATORS$1 = new Set(["Component", "Directive"]);
+const SUBJECT_NAMES = new Set([
+	"BehaviorSubject",
+	"ReplaySubject",
+	"Subject"
+]);
+const FIELD_NODE_TYPES$1 = new Set([
+	"AccessorProperty",
+	"FieldDefinition",
+	"PropertyDefinition"
+]);
+function hasTargetDecorator$2(context, classNode) {
+	if (!classNode || !Array.isArray(classNode.decorators)) return false;
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, TARGET_DECORATORS$1));
+}
+function getImportedSubjectKind(context, node) {
+	const importedName = getImportedName(context, node, "rxjs");
+	return SUBJECT_NAMES.has(importedName) ? importedName : null;
+}
+function getSubjectKindFromType(context, node) {
+	if (!node) return null;
+	if (node.type !== "TSTypeReference") return null;
+	if (node.typeName?.type === "Identifier") return getImportedSubjectKind(context, node.typeName);
+	if (node.typeName?.type === "TSQualifiedName" && node.typeName.left?.type === "Identifier") {
+		const memberName = getPropertyName(node.typeName.right);
+		return isNamespaceImport(context, node.typeName.left, "rxjs") && SUBJECT_NAMES.has(memberName) ? memberName : null;
+	}
+	return null;
+}
+function getSubjectKindFromConstructor(context, node) {
+	const expression = unwrapExpression(node);
+	if (expression?.type !== "NewExpression") return null;
+	const callee = unwrapExpression(expression.callee);
+	if (callee?.type === "Identifier") return getImportedSubjectKind(context, callee);
+	if (callee?.type !== "MemberExpression") return null;
+	if (callee.object?.type !== "Identifier" || !isNamespaceImport(context, callee.object, "rxjs")) return null;
+	const memberName = getPropertyName(callee.property);
+	return SUBJECT_NAMES.has(memberName) ? memberName : null;
+}
+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 getThisFieldName(node) {
+	const expression = unwrapExpression(node);
+	if (expression?.type !== "MemberExpression") return null;
+	if (expression.object?.type !== "ThisExpression") return null;
+	return getPropertyName(expression.property);
+}
+function isCallOnThisField(node, fields) {
+	const callNode = unwrapExpression(node);
+	if (callNode?.type !== "CallExpression") return null;
+	const callee = unwrapExpression(callNode.callee);
+	if (callee?.type !== "MemberExpression") return null;
+	const fieldName = getThisFieldName(callee.object);
+	const methodName = getPropertyName(callee.property);
+	if (!fieldName || !methodName || !fields.has(fieldName)) return null;
+	return {
+		fieldName,
+		methodName,
+		argumentCount: callNode.arguments?.length ?? 0
+	};
+}
+function isNgOnDestroyMethod(member) {
+	return member.type === "MethodDefinition" && getPropertyName(member.key) === "ngOnDestroy" && !!member.value;
+}
+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);
+	}
+}
+function getUsage(usages, fieldName) {
+	const existing = usages.get(fieldName);
+	if (existing) return existing;
+	const next = {
+		hasAsObservable: false,
+		hasNextWithValue: false,
+		hasNgOnDestroyComplete: false,
+		hasNgOnDestroyNext: false
+	};
+	usages.set(fieldName, next);
+	return next;
+}
+function collectSubjectFields(context, classBody) {
+	const fields = /* @__PURE__ */ new Map();
+	for (const member of classBody.body ?? []) {
+		if (!FIELD_NODE_TYPES$1.has(member.type)) continue;
+		const fieldName = getMemberName(member.key);
+		if (!fieldName) continue;
+		const typeNode = member.typeAnnotation?.typeAnnotation;
+		const kind = getSubjectKindFromConstructor(context, member.value) ?? getSubjectKindFromType(context, typeNode);
+		if (!kind) continue;
+		fields.set(fieldName, {
+			key: member.key ?? member,
+			kind
+		});
+	}
+	return fields;
+}
+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) => {
+		const call = isCallOnThisField(node, fields);
+		if (!call) return;
+		const usage = getUsage(usages, call.fieldName);
+		if (call.methodName === "asObservable") usage.hasAsObservable = true;
+		if (call.methodName === "next" && call.argumentCount > 0) usage.hasNextWithValue = true;
+		const isInsideNgOnDestroy = ngOnDestroyMethods.has(node.parent) || ngOnDestroyMethods.has(node);
+		let current = node.parent;
+		while (!isInsideNgOnDestroy && current) {
+			if (ngOnDestroyMethods.has(current)) break;
+			current = current.parent;
+		}
+		if (!current && !ngOnDestroyMethods.has(node.parent) && !ngOnDestroyMethods.has(node)) return;
+		if (call.methodName === "next") usage.hasNgOnDestroyNext = true;
+		if (call.methodName === "complete") usage.hasNgOnDestroyComplete = true;
+	});
+	return usages;
+}
+function isDestroySubjectUsage(usage) {
+	return !!usage?.hasNgOnDestroyNext && !!usage.hasNgOnDestroyComplete;
+}
+const avoidRxjsStateInComponent = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Avoid using RxJS Subject classes for component or directive state and destruction lifecycle.",
+			recommended: true
+		},
+		schema: [],
+		messages: {
+			avoidRxjsState: "Avoid using RxJS {{kind}} for component/directive state. Prefer signal(), computed(), or linkedSignal().",
+			avoidDestroySubject: "Avoid destroy Subject lifecycle management. Prefer takeUntilDestroyed() from @angular/core/rxjs-interop."
 		}
 	},
 	createOnce(context) {
-		return { Decorator(node) {
-			const options = context.options[0] ?? {};
-			const allowForGrouping = options.allowForGrouping ?? DEFAULT_ALLOW_FOR_GROUPING;
-			const allowForProviding = options.allowForProviding ?? DEFAULT_ALLOW_FOR_PROVIDING;
-			const allowForRouting = options.allowForRouting ?? DEFAULT_ALLOW_FOR_ROUTING;
-			const metadata = getNgModuleMetadata(node);
-			if (!metadata) return;
-			const importsElements = getArrayElementsFromProperty(metadata, "imports");
-			const exportsElements = getArrayElementsFromProperty(metadata, "exports");
-			if (!allowForGrouping && (importsElements.length > 0 || exportsElements.length > 0)) context.report({
-				node,
-				messageId: "avoidModuleImportsExports"
-			});
-			const importCalls = importsElements.filter((element) => element.type === "CallExpression");
-			if (!allowForProviding) {
-				for (const call of importCalls) {
-					if (!isMemberCall(call, "forRoot")) continue;
+		return { ClassBody(node) {
+			const classBody = node;
+			const classNode = classBody.parent;
+			if (!hasTargetDecorator$2(context, classNode)) return;
+			const fields = collectSubjectFields(context, classBody);
+			const usages = collectFieldUsages(classBody, fields);
+			for (const [fieldName, field] of fields) {
+				const usage = usages.get(fieldName);
+				if (field.kind === "Subject" && isDestroySubjectUsage(usage)) {
 					context.report({
-						node: call,
-						messageId: "avoidForRoot"
+						node: field.key,
+						messageId: "avoidDestroySubject"
 					});
+					continue;
 				}
-				const staticForRootMethod = getStaticForRootMethod(getNgModuleClassNode(node));
-				if (staticForRootMethod) context.report({
-					node: staticForRootMethod.key ?? staticForRootMethod,
-					messageId: "avoidForRoot"
-				});
-			}
-			if (!allowForRouting) for (const call of importCalls) {
-				if (!isRouterModuleForChild(call)) continue;
 				context.report({
-					node: call,
-					messageId: "avoidRouterForChild"
+					node: field.key,
+					messageId: "avoidRxjsState",
+					data: { kind: field.kind }
 				});
 			}
 		} };
@@ -322,39 +1209,49 @@ const KNOWN_SIGNAL_CREATION_FUNCTIONS = new Set([
 ]);
 const LINKED_SIGNAL_CREATOR_NAME = "linkedSignal";
 const COMPUTED_CREATOR_NAME = "computed";
-const EFFECT_CREATOR_NAME = "effect";
-function isAngularCoreNamespaceMember(node, angularNamespaces, memberName) {
-	return node?.type === "MemberExpression" && node.object?.type === "Identifier" && angularNamespaces.has(node.object.name) && getPropertyName(node.property) === memberName;
-}
-function isSignalCreatorCall(node, signalCreatorNames, angularNamespaces) {
+const EFFECT_CREATOR_NAMES = new Set(["effect"]);
+const COMPUTED_CREATOR_NAMES = new Set([COMPUTED_CREATOR_NAME]);
+const LINKED_SIGNAL_CREATOR_NAMES = new Set([LINKED_SIGNAL_CREATOR_NAME]);
+function isSignalCreatorCall(context, node) {
 	if (node?.type !== "CallExpression") return false;
 	const callee = node.callee;
-	return callee?.type === "Identifier" && signalCreatorNames.has(callee.name) || [...KNOWN_SIGNAL_CREATION_FUNCTIONS].some((name) => isAngularCoreNamespaceMember(callee, angularNamespaces, name));
+	return isImportedReference(context, callee, "@angular/core", KNOWN_SIGNAL_CREATION_FUNCTIONS) || isImportedNamespaceMember(context, callee, "@angular/core", KNOWN_SIGNAL_CREATION_FUNCTIONS);
 }
-function isEffectCall(node, effectNames, angularNamespaces) {
+function isEffectCall(context, node) {
 	const callee = node.callee;
-	return callee?.type === "Identifier" && effectNames.has(callee.name) || isAngularCoreNamespaceMember(callee, angularNamespaces, "effect");
+	return isImportedReference(context, callee, "@angular/core", EFFECT_CREATOR_NAMES) || isImportedNamespaceMember(context, callee, "@angular/core", EFFECT_CREATOR_NAMES);
 }
-function isReactiveCreatorCall(node, creatorNames, angularNamespaces, angularMemberName) {
+function isReactiveCreatorCall(context, node, creatorNames) {
 	const callee = node.callee;
-	return callee?.type === "Identifier" && creatorNames.has(callee.name) || isAngularCoreNamespaceMember(callee, angularNamespaces, angularMemberName);
+	return isImportedReference(context, callee, "@angular/core", creatorNames) || isImportedNamespaceMember(context, callee, "@angular/core", creatorNames);
 }
-function isKnownSignalObject(objectNode, signalVariables, classSignalProperties) {
+function isKnownSignalObject(context, objectNode, signalVariableBindings, classSignalProperties) {
 	if (!objectNode) return false;
-	if (objectNode.type === "Identifier") return signalVariables.has(objectNode.name);
+	if (objectNode.type === "Identifier") {
+		const trackedBindings = signalVariableBindings.get(objectNode.name);
+		if (!trackedBindings) return false;
+		const nearestBinding = findNearestBindingIdentifier(context, objectNode);
+		return !!nearestBinding && trackedBindings.has(nearestBinding);
+	}
 	return objectNode.type === "MemberExpression" && objectNode.object?.type === "ThisExpression" && objectNode.property?.type === "Identifier" && classSignalProperties.has(objectNode.property.name);
 }
-function visitNodes$1(node, visitor) {
+const FUNCTION_NODE_TYPES = new Set([
+	"ArrowFunctionExpression",
+	"FunctionExpression",
+	"FunctionDeclaration"
+]);
+function visitNodes(node, visitor, skipFunctionBodies = false) {
 	if (!node) return;
 	if (Array.isArray(node)) {
-		for (const item of node) visitNodes$1(item, visitor);
+		for (const item of node) visitNodes(item, visitor, skipFunctionBodies);
 		return;
 	}
+	if (skipFunctionBodies && FUNCTION_NODE_TYPES.has(node.type)) return;
 	visitor(node);
 	for (const [key, value] of Object.entries(node)) {
 		if (key === "parent") continue;
 		if (!value || typeof value !== "object") continue;
-		visitNodes$1(value, visitor);
+		visitNodes(value, visitor, skipFunctionBodies);
 	}
 }
 const avoidWritingSignalsInReactiveContext = defineRule({
@@ -381,46 +1278,25 @@ const avoidWritingSignalsInReactiveContext = defineRule({
 		messages: { avoidSignalWriteInReactiveContext: "Avoid setting signal values inside {{contextName}}; move writes outside reactive derivations and effects." }
 	},
 	createOnce(context) {
-		const effectNames = /* @__PURE__ */ new Set();
-		const computedNames = /* @__PURE__ */ new Set();
-		const linkedSignalNames = /* @__PURE__ */ new Set();
-		const signalCreatorNames = /* @__PURE__ */ new Set();
-		const angularNamespaces = /* @__PURE__ */ new Set();
-		const signalVariables = /* @__PURE__ */ new Set();
+		const signalVariableBindings = /* @__PURE__ */ new Map();
 		const classSignalProperties = /* @__PURE__ */ new Set();
 		return {
 			before() {
-				effectNames.clear();
-				computedNames.clear();
-				linkedSignalNames.clear();
-				signalCreatorNames.clear();
-				angularNamespaces.clear();
-				signalVariables.clear();
+				signalVariableBindings.clear();
 				classSignalProperties.clear();
 			},
-			ImportDeclaration(node) {
-				if (node.source?.value !== "@angular/core") return;
-				for (const specifier of node.specifiers ?? []) {
-					if (specifier.type === "ImportSpecifier") {
-						const importedName = getPropertyName(specifier.imported);
-						if (importedName === EFFECT_CREATOR_NAME) effectNames.add(specifier.local.name);
-						if (importedName === COMPUTED_CREATOR_NAME) computedNames.add(specifier.local.name);
-						if (importedName === LINKED_SIGNAL_CREATOR_NAME) linkedSignalNames.add(specifier.local.name);
-						if (importedName && KNOWN_SIGNAL_CREATION_FUNCTIONS.has(importedName)) signalCreatorNames.add(specifier.local.name);
-					}
-					if (specifier.type === "ImportNamespaceSpecifier") angularNamespaces.add(specifier.local.name);
-				}
-			},
 			VariableDeclarator(node) {
 				const declarator = node;
 				if (declarator.id?.type !== "Identifier") return;
-				if (!isSignalCreatorCall(declarator.init, signalCreatorNames, angularNamespaces)) return;
-				signalVariables.add(declarator.id.name);
+				if (!isSignalCreatorCall(context, declarator.init)) return;
+				const bindings = signalVariableBindings.get(declarator.id.name) ?? /* @__PURE__ */ new Set();
+				bindings.add(declarator.id);
+				signalVariableBindings.set(declarator.id.name, bindings);
 			},
 			"PropertyDefinition, FieldDefinition, AccessorProperty"(node) {
 				const property = node;
 				if (property.key?.type !== "Identifier") return;
-				if (!isSignalCreatorCall(property.value, signalCreatorNames, angularNamespaces)) return;
+				if (!isSignalCreatorCall(context, property.value)) return;
 				classSignalProperties.add(property.key.name);
 			},
 			CallExpression(node) {
@@ -429,21 +1305,21 @@ const avoidWritingSignalsInReactiveContext = defineRule({
 				const allowComputedAndLinkedSignals = options.allowComputedAndLinkedSignals ?? false;
 				const callNode = node;
 				const callbackCandidates = [];
-				if (!allowEffects && isEffectCall(callNode, effectNames, angularNamespaces)) {
+				if (!allowEffects && isEffectCall(context, callNode)) {
 					const callback = callNode.arguments?.[0];
 					if (callback?.type === "ArrowFunctionExpression" || callback?.type === "FunctionExpression") callbackCandidates.push({
 						callback,
 						contextName: "effect()"
 					});
 				}
-				if (!allowComputedAndLinkedSignals && isReactiveCreatorCall(callNode, computedNames, angularNamespaces, COMPUTED_CREATOR_NAME)) {
+				if (!allowComputedAndLinkedSignals && isReactiveCreatorCall(context, callNode, COMPUTED_CREATOR_NAMES)) {
 					const callback = callNode.arguments?.[0];
 					if (callback?.type === "ArrowFunctionExpression" || callback?.type === "FunctionExpression") callbackCandidates.push({
 						callback,
 						contextName: "computed()"
 					});
 				}
-				if (!allowComputedAndLinkedSignals && isReactiveCreatorCall(callNode, linkedSignalNames, angularNamespaces, LINKED_SIGNAL_CREATOR_NAME)) for (const argumentNode of callNode.arguments ?? []) {
+				if (!allowComputedAndLinkedSignals && isReactiveCreatorCall(context, callNode, LINKED_SIGNAL_CREATOR_NAMES)) for (const argumentNode of callNode.arguments ?? []) {
 					const argument = argumentNode;
 					if (argument.type === "ArrowFunctionExpression" || argument.type === "FunctionExpression") {
 						callbackCandidates.push({
@@ -464,77 +1340,167 @@ const avoidWritingSignalsInReactiveContext = defineRule({
 						});
 					}
 				}
-				for (const { callback, contextName } of callbackCandidates) visitNodes$1(callback.body, (current) => {
+				for (const { callback, contextName } of callbackCandidates) visitNodes(callback.body, (current) => {
 					if (current.type !== "CallExpression") return;
 					const callee = current.callee;
 					if (callee?.type !== "MemberExpression") return;
 					const methodName = getPropertyName(callee.property);
 					if (!methodName || !SIGNAL_WRITE_METHODS.has(methodName)) return;
-					if (!isKnownSignalObject(callee.object, signalVariables, classSignalProperties)) return;
+					if (!isKnownSignalObject(context, callee.object, signalVariableBindings, classSignalProperties)) return;
 					context.report({
 						node: callee.property ?? callee,
 						messageId: "avoidSignalWriteInReactiveContext",
 						data: { contextName }
 					});
-				});
+				}, true);
 			},
-			"Program:exit"() {
-				effectNames.clear();
-				computedNames.clear();
-				linkedSignalNames.clear();
-				signalCreatorNames.clear();
-				angularNamespaces.clear();
-				signalVariables.clear();
+			after() {
+				signalVariableBindings.clear();
 				classSignalProperties.clear();
 			}
 		};
 	}
 });
 //#endregion
-//#region src/rules/component-class-matches-filename/index.ts
+//#region src/rules/class-matches-filename/index.ts
+const CLASS_FILENAME_MATCHERS = [
+	{
+		pattern: /^(.*)\.component\.ts$/u,
+		decoratorNames: ["Component"]
+	},
+	{
+		pattern: /^(.*)\.directive\.ts$/u,
+		decoratorNames: ["Directive"]
+	},
+	{
+		pattern: /^(.*)\.service\.ts$/u,
+		decoratorNames: ["Service", "Injectable"]
+	}
+];
 function toPascalCase(raw) {
 	return raw.split(/[-_\s.]+/u).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
 }
-function getExpectedComponentClassName(filename) {
+function getClassKind(suffix) {
+	return suffix.toLowerCase();
+}
+function getExpectedClassNames(filename, ignoreClassSuffix) {
 	const base = filename.split(/[/\\]/u).at(-1) ?? "";
-	const match = /^(.*)\.component\.ts$/u.exec(base);
-	if (!match) return null;
-	const stem = match[1];
-	const pascal = toPascalCase(stem);
-	return pascal ? `${pascal}Component` : null;
+	for (const { decoratorNames, pattern } of CLASS_FILENAME_MATCHERS) {
+		const match = pattern.exec(base);
+		if (!match) continue;
+		const stem = match[1];
+		const pascal = toPascalCase(stem);
+		if (!pascal) return null;
+		const suffix = decoratorNames[0];
+		return ignoreClassSuffix ? [`${pascal}${suffix}`, pascal] : [`${pascal}${suffix}`];
+	}
+	return null;
+}
+function getFileMatcher(filename) {
+	const base = filename.split(/[/\\]/u).at(-1) ?? "";
+	return CLASS_FILENAME_MATCHERS.find(({ pattern }) => pattern.test(base)) ?? null;
 }
-const componentClassMatchesFilename = defineRule({
+function getIgnoreClassSuffixOption(options, kind) {
+	const ignoreClassSuffix = options.ignoreClassSuffix ?? false;
+	if (typeof ignoreClassSuffix === "boolean") return ignoreClassSuffix;
+	return ignoreClassSuffix[kind] ?? false;
+}
+function getFileKind(matcher) {
+	return getClassKind(matcher.decoratorNames[0]);
+}
+function formatExpectedNames(expectedNames) {
+	return expectedNames.join("' or '");
+}
+function getNodeName(node) {
+	return node.id?.name ?? null;
+}
+function getBaseFilename$1(filename) {
+	return filename.split(/[/\\]/u).at(-1) ?? filename;
+}
+function hasTargetDecorator$1(context, classNode, decoratorNames) {
+	if (!Array.isArray(classNode.decorators)) return false;
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, decoratorNames));
+}
+function getDecoratedClassCountDescription(count) {
+	return count === 0 ? "no decorated classes" : `${count} decorated classes`;
+}
+const classMatchesFilename = defineRule({
 	meta: {
 		type: "suggestion",
 		docs: {
-			description: "Require the component class name to match its *.component.ts filename.",
+			description: "Require Angular component, directive, and service class names to match their filenames.",
 			recommended: true
 		},
-		schema: [],
-		messages: { classNameMismatch: "Component class name should be '{{expectedName}}' to match the filename '{{filename}}'." }
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: { ignoreClassSuffix: {
+				anyOf: [{ type: "boolean" }, {
+					type: "object",
+					additionalProperties: false,
+					properties: {
+						component: { type: "boolean" },
+						directive: { type: "boolean" },
+						service: { type: "boolean" }
+					}
+				}],
+				default: false
+			} }
+		}],
+		messages: {
+			classNameMismatch: "Angular class name should be '{{expectedName}}' to match the filename '{{filename}}'.",
+			decoratedClassCount: "Angular filename '{{filename}}' should contain exactly one matching decorated class, but found {{actual}}."
+		}
 	},
 	createOnce(context) {
-		const classDeclarations = [];
+		let programNode = null;
+		let fileMatcher = null;
+		let fileDecoratorNames = /* @__PURE__ */ new Set();
+		const decoratedClasses = [];
 		return {
 			before() {
-				classDeclarations.length = 0;
+				programNode = null;
+				decoratedClasses.length = 0;
+				fileMatcher = getFileMatcher(context.filename ?? "");
+				if (!fileMatcher) return false;
+				fileDecoratorNames = new Set(fileMatcher.decoratorNames);
+			},
+			Program(node) {
+				programNode = node;
 			},
 			ClassDeclaration(node) {
-				classDeclarations.push(node);
+				if (!fileMatcher) return;
+				const classNode = node;
+				if (hasTargetDecorator$1(context, classNode, fileDecoratorNames)) decoratedClasses.push(classNode);
 			},
 			after() {
 				const filename = context.filename ?? "";
-				const expectedName = getExpectedComponentClassName(filename);
-				if (!expectedName) return;
-				const baseFilename = filename.split(/[/\\]/u).at(-1) ?? filename;
-				const classNode = classDeclarations.find((candidate) => candidate.parent?.type === "ExportNamedDeclaration" || candidate.parent?.type === "ExportDefaultDeclaration") ?? null ?? classDeclarations[0];
-				if (!classNode?.id?.name) return;
-				if (classNode.id.name === expectedName) return;
+				if (!fileMatcher) return;
+				const baseFilename = getBaseFilename$1(filename);
+				if (decoratedClasses.length !== 1) {
+					const reportNode = decoratedClasses[0]?.id ?? decoratedClasses[0] ?? programNode;
+					if (!reportNode) return;
+					context.report({
+						node: reportNode,
+						messageId: "decoratedClassCount",
+						data: {
+							actual: getDecoratedClassCountDescription(decoratedClasses.length),
+							filename: baseFilename
+						}
+					});
+					return;
+				}
+				const expectedNames = getExpectedClassNames(filename, getIgnoreClassSuffixOption(context.options[0] ?? {}, getFileKind(fileMatcher)));
+				if (!expectedNames) return;
+				const classNode = decoratedClasses[0];
+				const className = getNodeName(classNode);
+				if (!className) return;
+				if (expectedNames.includes(className)) return;
 				context.report({
 					node: classNode.id,
 					messageId: "classNameMismatch",
 					data: {
-						expectedName,
+						expectedName: formatExpectedNames(expectedNames),
 						filename: baseFilename
 					}
 				});
@@ -543,13 +1509,208 @@ const componentClassMatchesFilename = defineRule({
 	}
 });
 //#endregion
+//#region src/rules/component-resource-filenames/index.ts
+const COMPONENT_DECORATORS$1 = new Set(["Component"]);
+const STYLE_EXTENSIONS = new Set([
+	"css",
+	"less",
+	"sass",
+	"scss"
+]);
+function getExpectedStem(filename) {
+	const base = filename.split(/[/\\]/u).at(-1) ?? "";
+	if (!base.endsWith(".ts")) return null;
+	return base.slice(0, -3);
+}
+function normalizeResourcePath(value) {
+	return value.startsWith("./") ? value.slice(2) : value;
+}
+function getResourceBasename(value) {
+	return normalizeResourcePath(value).split(/[/\\]/u).at(-1) ?? value;
+}
+function getExtension(value) {
+	const basename = getResourceBasename(value);
+	const index = basename.lastIndexOf(".");
+	return index === -1 ? null : basename.slice(index + 1);
+}
+function getStaticString(node) {
+	if (!node) return null;
+	if (node.type === "Literal" || node.type === "StringLiteral") {
+		if (typeof node.value !== "string") return null;
+		return { value: node.value };
+	}
+	if (node.type === "TemplateLiteral" && node.expressions?.length === 0) return { value: node.quasis?.[0]?.value?.cooked ?? node.quasis?.[0]?.value?.raw ?? "" };
+	return null;
+}
+function getComponentMetadata(context, node) {
+	if (node.type !== "Decorator") return null;
+	if (!isAngularCoreDecorator(context, node, COMPONENT_DECORATORS$1)) return null;
+	const expression = node.expression;
+	if (expression?.type !== "CallExpression") return null;
+	const metadata = expression.arguments?.[0];
+	return metadata?.type === "ObjectExpression" ? metadata : null;
+}
+const componentResourceFilenames = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Require Angular component templateUrl and styleUrl resource filenames to match the component TypeScript filename.",
+			recommended: true
+		},
+		schema: [],
+		messages: {
+			templateUrlMismatch: "Component templateUrl should be '{{expected}}' to match this component filename.",
+			styleUrlMismatch: "Component style URL should be '{{expected}}' to match this component filename.",
+			unsupportedStyleExtension: "Component style URL should use one of: .css, .less, .sass, or .scss."
+		}
+	},
+	createOnce(context) {
+		let expectedStem = null;
+		function reportTemplateUrl(valueNode) {
+			if (!expectedStem) return;
+			const staticString = getStaticString(valueNode);
+			if (!staticString) return;
+			const expected = `./${expectedStem}.html`;
+			if (normalizeResourcePath(staticString.value) === `${expectedStem}.html`) return;
+			context.report({
+				node: valueNode,
+				messageId: "templateUrlMismatch",
+				data: { expected }
+			});
+		}
+		function reportStyleUrl(valueNode) {
+			if (!expectedStem) return;
+			const staticString = getStaticString(valueNode);
+			if (!staticString) return;
+			const extension = getExtension(staticString.value);
+			if (!extension || !STYLE_EXTENSIONS.has(extension)) {
+				context.report({
+					node: valueNode,
+					messageId: "unsupportedStyleExtension"
+				});
+				return;
+			}
+			const expected = `./${expectedStem}.${extension}`;
+			if (normalizeResourcePath(staticString.value) === `${expectedStem}.${extension}`) return;
+			context.report({
+				node: valueNode,
+				messageId: "styleUrlMismatch",
+				data: { expected }
+			});
+		}
+		return {
+			before() {
+				expectedStem = getExpectedStem(context.filename ?? "");
+				if (!expectedStem) return false;
+			},
+			Decorator(node) {
+				const metadata = getComponentMetadata(context, node);
+				if (!metadata) return;
+				for (const property of metadata.properties ?? []) {
+					if (property.type !== "Property" || property.computed) continue;
+					const propertyName = getPropertyName(property.key);
+					if (propertyName === "templateUrl") {
+						reportTemplateUrl(property.value);
+						continue;
+					}
+					if (propertyName === "styleUrl") {
+						reportStyleUrl(property.value);
+						continue;
+					}
+				}
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/decorator-filename-suffix/index.ts
+const FILENAME_SUFFIX_CONVENTIONS = [
+	{
+		kind: "component",
+		suffix: ".component.ts",
+		decoratorNames: new Set(["Component"])
+	},
+	{
+		kind: "directive",
+		suffix: ".directive.ts",
+		decoratorNames: new Set(["Directive"])
+	},
+	{
+		kind: "service",
+		suffix: ".service.ts",
+		decoratorNames: new Set(["Service", "Injectable"])
+	}
+];
+function getBaseFilename(filename) {
+	return filename.split(/[/\\]/u).at(-1) ?? filename;
+}
+function isTypeScriptFile(filename) {
+	return getBaseFilename(filename).endsWith(".ts");
+}
+function getMatchingConvention(context, decorator) {
+	return FILENAME_SUFFIX_CONVENTIONS.find((convention) => isAngularCoreDecorator(context, decorator, convention.decoratorNames)) ?? null;
+}
+const decoratorFilenameSuffix = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Require Angular component, directive, and service decorators to be declared in files with matching suffixes.",
+			recommended: true
+		},
+		schema: [],
+		messages: { filenameSuffix: "Angular {{kind}} decorator should be declared in a file ending with '{{suffix}}'." }
+	},
+	createOnce(context) {
+		return {
+			before() {
+				if (!isTypeScriptFile(context.filename ?? "")) return false;
+			},
+			Decorator(node) {
+				const convention = getMatchingConvention(context, node);
+				if (!convention) return;
+				if (getBaseFilename(context.filename ?? "").endsWith(convention.suffix)) return;
+				context.report({
+					node,
+					messageId: "filenameSuffix",
+					data: {
+						kind: convention.kind,
+						suffix: convention.suffix
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
 //#region src/rules/prefer-load-component-over-load-children/index.ts
-function isRoutesTypeAnnotation(node) {
+const ROUTE_TYPE_NAMES = new Set(["Route"]);
+const ROUTES_TYPE_NAMES = new Set(["Routes"]);
+function isImportedTypeName(context, typeNode, importedNames) {
+	if (typeNode?.type === "Identifier") {
+		const importedName = getImportedName(context, typeNode, "@angular/router");
+		return !!importedName && importedNames.has(importedName);
+	}
+	return typeNode?.type === "TSQualifiedName" && typeNode.left?.type === "Identifier" && isNamespaceImport(context, typeNode.left, "@angular/router") && importedNames.has(getPropertyName(typeNode.right) ?? "");
+}
+function getTypeParameterNodes(typeNode) {
+	return typeNode.typeParameters?.params ?? typeNode.typeArguments?.params ?? [];
+}
+function isRouteType(context, typeNode) {
+	return typeNode?.type === "TSTypeReference" && isImportedTypeName(context, typeNode.typeName, ROUTE_TYPE_NAMES);
+}
+function isRouteArrayType(context, typeNode) {
+	if (!typeNode) return false;
+	if (typeNode.type === "TSTypeReference" && isImportedTypeName(context, typeNode.typeName, ROUTES_TYPE_NAMES)) return true;
+	if (typeNode.type === "TSArrayType") return isRouteType(context, typeNode.elementType);
+	if (typeNode.type !== "TSTypeReference") return false;
+	if (getPropertyName(typeNode.typeName) !== "Array" && getPropertyName(typeNode.typeName) !== "ReadonlyArray") return false;
+	const [elementType] = getTypeParameterNodes(typeNode);
+	return isRouteType(context, elementType);
+}
+function isRoutesTypeAnnotation(context, node) {
 	const typeAnnotation = node?.typeAnnotation;
 	if (!typeAnnotation || typeAnnotation.type !== "TSTypeAnnotation") return false;
-	const annotation = typeAnnotation.typeAnnotation;
-	if (!annotation || annotation.type !== "TSTypeReference") return false;
-	return getPropertyName(annotation.typeName) === "Routes";
+	return isRouteArrayType(context, typeAnnotation.typeAnnotation);
 }
 function isExportedConstDeclarator(node) {
 	if (node.type !== "VariableDeclarator") return false;
@@ -557,19 +1718,6 @@ function isExportedConstDeclarator(node) {
 	if (declaration?.type !== "VariableDeclaration" || declaration.kind !== "const") return false;
 	return declaration.parent?.type === "ExportNamedDeclaration";
 }
-function visitNodes(node, visitor) {
-	if (!node) return;
-	if (Array.isArray(node)) {
-		for (const item of node) visitNodes(item, visitor);
-		return;
-	}
-	visitor(node);
-	for (const [key, value] of Object.entries(node)) {
-		if (key === "parent") continue;
-		if (!value || typeof value !== "object") continue;
-		visitNodes(value, visitor);
-	}
-}
 const preferLoadComponentOverLoadChildren = defineRule({
 	meta: {
 		type: "problem",
@@ -581,20 +1729,30 @@ const preferLoadComponentOverLoadChildren = defineRule({
 		messages: { avoidLoadChildren: "Avoid loadChildren in Routes arrays; prefer loadComponent for lazy-loading standalone route components." }
 	},
 	createOnce(context) {
+		function reportLoadChildrenInRouteObject(routeObject) {
+			for (const property of routeObject.properties ?? []) {
+				if (property.type !== "Property" || property.computed) continue;
+				const propertyName = getPropertyName(property.key);
+				if (propertyName === "loadChildren") {
+					context.report({
+						node: property.key ?? property,
+						messageId: "avoidLoadChildren"
+					});
+					continue;
+				}
+				if (propertyName === "children" && property.value?.type === "ArrayExpression") reportLoadChildrenInRouteArray(property.value);
+			}
+		}
+		function reportLoadChildrenInRouteArray(routeArray) {
+			for (const element of routeArray.elements ?? []) if (element?.type === "ObjectExpression") reportLoadChildrenInRouteObject(element);
+		}
 		return { VariableDeclarator(node) {
 			const declarator = node;
 			if (!isExportedConstDeclarator(declarator)) return;
 			if (declarator.id?.type !== "Identifier") return;
-			if (!isRoutesTypeAnnotation(declarator.id)) return;
+			if (!isRoutesTypeAnnotation(context, declarator.id)) return;
 			if (declarator.init?.type !== "ArrayExpression") return;
-			visitNodes(declarator.init.elements, (current) => {
-				if (current.type !== "Property" || current.computed) return;
-				if (getPropertyName(current.key) !== "loadChildren") return;
-				context.report({
-					node: current.key ?? current,
-					messageId: "avoidLoadChildren"
-				});
-			});
+			reportLoadChildrenInRouteArray(declarator.init);
 		} };
 	}
 });
@@ -604,6 +1762,7 @@ function getPrivateTarget(element) {
 	if (element.type !== "PropertyDefinition" && element.type !== "FieldDefinition" && element.type !== "AccessorProperty" && element.type !== "MethodDefinition") return null;
 	if (element.accessibility !== "private") return null;
 	if (element.computed) return null;
+	if (Array.isArray(element.decorators) && element.decorators.length > 0) return null;
 	if (element.type === "MethodDefinition" && element.kind === "constructor") return null;
 	const name = getPropertyName(element.key);
 	if (!name || element.key?.type !== "Identifier") return null;
@@ -757,10 +1916,10 @@ const preferPrivateElements = defineRule({
 });
 //#endregion
 //#region src/rules/prefer-style-url/index.ts
-function isComponentDecoratorCall(node) {
+const COMPONENT_DECORATORS = new Set(["Component"]);
+function isComponentDecoratorCall(context, node) {
 	const callee = node.callee;
-	if (callee?.type === "Identifier") return callee.name === "Component";
-	return callee?.type === "MemberExpression" && getPropertyName(callee.property) === "Component";
+	return isImportedReference(context, callee, "@angular/core", COMPONENT_DECORATORS) || isImportedNamespaceMember(context, callee, "@angular/core", COMPONENT_DECORATORS);
 }
 function isSingleStyleFileNode(node) {
 	if (!node) return false;
@@ -781,7 +1940,7 @@ const preferStyleUrl = defineRule({
 	createOnce(context) {
 		return { CallExpression(node) {
 			const call = node;
-			if (!isComponentDecoratorCall(call)) return;
+			if (!isComponentDecoratorCall(context, call)) return;
 			const metadata = call.arguments?.[0];
 			if (metadata?.type !== "ObjectExpression") return;
 			for (const property of metadata.properties ?? []) {
@@ -806,11 +1965,117 @@ const preferStyleUrl = defineRule({
 	}
 });
 //#endregion
+//#region src/rules/public-component-interface/index.ts
+const TARGET_DECORATORS = 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"]);
+const FIELD_NODE_TYPES = new Set([
+	"AccessorProperty",
+	"FieldDefinition",
+	"PropertyDefinition"
+]);
+function hasTargetDecorator(context, classNode) {
+	if (!classNode || !Array.isArray(classNode.decorators)) return false;
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, TARGET_DECORATORS));
+}
+function isApiCallFromAngularCore(context, node, apiNames) {
+	if (!node || node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	if (isImportedReference(context, callee, "@angular/core", apiNames)) return true;
+	if (callee?.type !== "MemberExpression") return false;
+	const supportsRequiredApi = [...INPUT_MODEL_APIS].some((name) => apiNames.has(name));
+	if (getPropertyName(callee.property) === "required" && callee.object?.type === "Identifier") return supportsRequiredApi && isImportedReference(context, callee.object, "@angular/core", apiNames);
+	if (isImportedNamespaceMember(context, callee, "@angular/core", apiNames)) return true;
+	if (getPropertyName(callee.property) === "required" && callee.object?.type === "MemberExpression" && callee.object.object?.type === "Identifier") {
+		const namespaceApiName = getPropertyName(callee.object.property);
+		return supportsRequiredApi && !!namespaceApiName && apiNames.has(namespaceApiName) && isImportedNamespaceMember(context, callee.object, "@angular/core", apiNames);
+	}
+	return false;
+}
+function isNonPublicMember(memberNode) {
+	if (memberNode.key?.type === "PrivateIdentifier") return true;
+	return memberNode.accessibility === "private" || memberNode.accessibility === "protected";
+}
+function isPublicMember(memberNode) {
+	if (memberNode.key?.type === "PrivateIdentifier") return false;
+	return memberNode.accessibility !== "private" && memberNode.accessibility !== "protected";
+}
+function getAccessibilityModifierRange(context, memberNode) {
+	const memberRange = getRange(memberNode);
+	const keyRange = getRange(memberNode.key);
+	if (!memberRange || !keyRange) return null;
+	const prefixText = context.sourceCode.text.slice(memberRange[0], keyRange[0]);
+	const match = /\b(private|protected|public)\b/u.exec(prefixText);
+	if (!match) return null;
+	return [memberRange[0] + match.index, memberRange[0] + match.index + match[0].length];
+}
+function getVisibilityFix(context, memberNode, targetVisibility) {
+	if (memberNode.key?.type === "PrivateIdentifier") return void 0;
+	const keyRange = getRange(memberNode.key);
+	if (!keyRange) return void 0;
+	const accessibilityRange = getAccessibilityModifierRange(context, memberNode);
+	if (accessibilityRange) return (fixer) => fixer.replaceTextRange(accessibilityRange, targetVisibility);
+	return (fixer) => fixer.insertTextBeforeRange([keyRange[0], keyRange[0]], `${targetVisibility} `);
+}
+const publicComponentInterface = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Require component/directive signal interface members (input/model/output APIs) to be public, and it's dependencies to be non-public.",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: {
+			nonPublicInputModel: "Input/model member {{name}} must be public so the component/directive interface is externally accessible.",
+			nonPublicOutput: "Output member {{name}} must be public so the component/directive interface is externally accessible.",
+			publicInjectMember: "Injected member {{name}} should not be public; prefer protected (template access) or private/#private."
+		}
+	},
+	createOnce(context) {
+		return { ClassBody(node) {
+			const classNode = node.parent;
+			if (!hasTargetDecorator(context, classNode)) return;
+			for (const member of node.body ?? []) {
+				if (!FIELD_NODE_TYPES.has(member.type)) continue;
+				const isInputModelMember = isApiCallFromAngularCore(context, member.value, INPUT_MODEL_APIS);
+				const isOutputMember = isApiCallFromAngularCore(context, member.value, OUTPUT_APIS);
+				if (isInputModelMember && isNonPublicMember(member)) {
+					context.report({
+						node: member.key ?? member,
+						messageId: "nonPublicInputModel",
+						data: { name: getPropertyName(member.key) ?? "member" },
+						fix: getVisibilityFix(context, member, "public")
+					});
+					continue;
+				}
+				if (isOutputMember && isNonPublicMember(member)) {
+					context.report({
+						node: member.key ?? member,
+						messageId: "nonPublicOutput",
+						data: { name: getPropertyName(member.key) ?? "member" },
+						fix: getVisibilityFix(context, member, "public")
+					});
+					continue;
+				}
+				if (isPublicMember(member) && isApiCallFromAngularCore(context, member.value, INJECT_APIS)) context.report({
+					node: member.key ?? member,
+					messageId: "publicInjectMember",
+					data: { name: getPropertyName(member.key) ?? "member" },
+					fix: getVisibilityFix(context, member, "protected")
+				});
+			}
+		} };
+	}
+});
+//#endregion
 //#region src/rules/restrict-injectable-provided-in/index.ts
 const ALLOWED_PROVIDED_IN_VALUES = new Set(["root", "platform"]);
-function getInjectableMetadata(node) {
+const INJECTABLE_DECORATORS = new Set(["Injectable"]);
+function getInjectableMetadata(context, node) {
 	if (node.type !== "Decorator") return null;
-	if (getDecoratorName(node) !== "Injectable") return null;
+	if (!isAngularCoreDecorator(context, node, INJECTABLE_DECORATORS)) return null;
 	const expression = node.expression;
 	if (expression?.type !== "CallExpression") return null;
 	const metadata = expression.arguments?.[0];
@@ -832,11 +2097,11 @@ const restrictInjectableProvidedIn = defineRule({
 			recommended: true
 		},
 		schema: [],
-		messages: { disallowedProvidedIn: "@Injectable providedIn should be 'root' or 'platform', not {{actual}}." }
+		messages: { disallowedProvidedIn: "@Injectable providedIn should be the literal 'root' or 'platform', not {{actual}}." }
 	},
 	createOnce(context) {
 		return { Decorator(node) {
-			const metadata = getInjectableMetadata(node);
+			const metadata = getInjectableMetadata(context, node);
 			if (!metadata) return;
 			const providedInProperty = getProvidedInProperty(metadata);
 			if (!providedInProperty) return;
@@ -878,6 +2143,37 @@ const ANGULAR_CLASS_DECORATOR_NAMES = new Set([
 	"NgModule"
 ]);
 const INJECTION_CONTEXT_RUNNER_NAMES = new Set(["runInInjectionContext", "runInContext"]);
+const KNOWN_INJECTION_CONTEXT_API_IMPORTS = [
+	{
+		from: "@angular/core",
+		imports: [
+			"afterEveryRender",
+			"afterNextRender",
+			"afterRender",
+			"afterRenderEffect",
+			"assertInInjectionContext",
+			"effect",
+			"inject",
+			"resource"
+		]
+	},
+	{
+		from: "@angular/core/rxjs-interop",
+		imports: [
+			"rxResource",
+			"toObservable",
+			"toSignal"
+		]
+	},
+	{
+		from: "@angular/common/http",
+		imports: ["httpResource"]
+	},
+	{
+		from: "@angular/forms/signals",
+		imports: ["form"]
+	}
+];
 const INJECTION_CONTEXT_FUNCTION_TYPE_NAMES = new Set([
 	"CanActivateFn",
 	"CanActivateChildFn",
@@ -898,17 +2194,6 @@ const CLASS_FIELD_TYPES = new Set([
 	"FieldDefinition",
 	"PropertyDefinition"
 ]);
-function getTypeName(node) {
-	if (!node) return null;
-	if (node.type === "Identifier") return node.name;
-	if (node.type === "TSTypeReference") return getTypeName(node.typeName);
-	if (node.type === "TSQualifiedName") {
-		const left = getTypeName(node.left);
-		const right = getTypeName(node.right);
-		return left && right ? `${left}.${right}` : right ?? left;
-	}
-	return null;
-}
 function isFunction(node) {
 	return !!node && FUNCTION_TYPES.has(node.type);
 }
@@ -975,11 +2260,6 @@ function isTypedInjectionContextFunction(functionNode) {
 	const unqualifiedTypeName = typeName.includes(".") ? typeName.split(".").at(-1) : typeName;
 	return INJECTION_CONTEXT_FUNCTION_TYPE_NAMES.has(unqualifiedTypeName ?? typeName);
 }
-function getNodeStart(node) {
-	if (typeof node.start === "number") return node.start;
-	if (Array.isArray(node.range) && typeof node.range[0] === "number") return node.range[0];
-	return null;
-}
 function hasAwaitBeforeNodeInFunction(functionNode, node) {
 	const nodeStart = getNodeStart(node);
 	if (nodeStart === null) return false;
@@ -1027,16 +2307,27 @@ function isAllowedInjectionContext(context, node, allowedFunctionNames, injectFu
 	const functionName = getFunctionName(nearestFunction);
 	return functionName ? allowedFunctionNames.has(functionName) || injectFunctionPrefixes.some((prefix) => functionName.startsWith(prefix)) || injectFunctionSuffixes.some((suffix) => functionName.endsWith(suffix)) : false;
 }
-function isAngularInjectCall(node, injectNames, angularNamespaces, checkUnimportedInject) {
+function getKnownInjectionContextApiImports(source) {
+	const apiImports = KNOWN_INJECTION_CONTEXT_API_IMPORTS.find((entry) => entry.from === source);
+	return apiImports ? new Set(apiImports.imports) : null;
+}
+function isKnownInjectionContextApiCall(context, node, injectionContextApiLocalNames, injectionContextApiNamespaceMembers, checkUnimportedInject) {
 	const callee = node.callee;
-	if (callee?.type === "Identifier") return injectNames.has(callee.name) || checkUnimportedInject && callee.name === "inject";
-	return callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && angularNamespaces.has(callee.object.name) && getPropertyName(callee.property) === "inject";
+	if (callee?.type === "Identifier") return injectionContextApiLocalNames.has(callee.name) && !isShadowedIdentifier(context, callee) || checkUnimportedInject && callee.name === "inject" && !isShadowedIdentifier(context, callee);
+	if (callee?.type !== "MemberExpression") return false;
+	if (callee.object?.type === "Identifier") {
+		if (injectionContextApiLocalNames.has(callee.object.name) && !isShadowedIdentifier(context, callee.object)) return true;
+		return !!injectionContextApiNamespaceMembers.get(callee.object.name)?.has(getPropertyName(callee.property) ?? "") && !isShadowedIdentifier(context, callee.object);
+	}
+	if (callee.object?.type === "MemberExpression" && callee.object.object?.type === "Identifier") return !!injectionContextApiNamespaceMembers.get(callee.object.object.name)?.has(getPropertyName(callee.object.property) ?? "") && !isShadowedIdentifier(context, callee.object.object);
+	return false;
 }
-function isInjectLikeHelperCall(node, injectNames, injectFunctionPrefixes, injectFunctionSuffixes, runsInInjectionContextFunctionNames) {
+function isInjectLikeHelperCall(context, node, injectionContextApiLocalNames, injectFunctionPrefixes, injectFunctionSuffixes, runsInInjectionContextFunctionNames) {
 	const callee = node.callee;
 	if (callee?.type !== "Identifier") return false;
+	if (isShadowedIdentifier(context, callee)) return false;
 	if (runsInInjectionContextFunctionNames.has(callee.name)) return true;
-	return !injectNames.has(callee.name) && callee.name !== "inject" && (injectFunctionPrefixes.some((prefix) => callee.name.startsWith(prefix)) || injectFunctionSuffixes.some((suffix) => callee.name.endsWith(suffix)));
+	return !injectionContextApiLocalNames.has(callee.name) && callee.name !== "inject" && (injectFunctionPrefixes.some((prefix) => callee.name.startsWith(prefix)) || injectFunctionSuffixes.some((suffix) => callee.name.endsWith(suffix)));
 }
 //#endregion
 //#region src/index.ts
@@ -1044,19 +2335,24 @@ const plugin = eslintCompatPlugin({
 	meta: { name: "@benjavicente/lint-angular" },
 	rules: {
 		"avoid-explicit-injection-context": avoidExplicitInjectionContext,
+		"avoid-explicit-subscription-management": avoidExplicitSubscriptionManagement,
 		"avoid-ng-modules": avoidNgModules,
+		"avoid-rxjs-state-in-component": avoidRxjsStateInComponent,
 		"avoid-writing-signals-in-reactive-context": avoidWritingSignalsInReactiveContext,
 		"class-member-order": classMemberOrder,
-		"component-class-matches-filename": componentClassMatchesFilename,
+		"class-matches-filename": classMatchesFilename,
+		"component-resource-filenames": componentResourceFilenames,
+		"decorator-filename-suffix": decoratorFilenameSuffix,
 		"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({
 			meta: {
 				type: "problem",
 				docs: {
-					description: "Require Angular inject() calls to appear only in known injection contexts.",
+					description: "Require Angular APIs that depend on injection context to appear only in known injection contexts.",
 					recommended: true
 				},
 				schema: [{
@@ -1100,17 +2396,17 @@ const plugin = eslintCompatPlugin({
 						}
 					}
 				}],
-				messages: { disallowedInject: "Angular inject() 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." }
+				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 injectNames = /* @__PURE__ */ new Set();
-				const angularNamespaces = /* @__PURE__ */ new Set();
+				const injectionContextApiLocalNames = /* @__PURE__ */ new Set();
+				const injectionContextApiNamespaceMembers = /* @__PURE__ */ new Map();
 				const runsInInjectionContextFunctionNames = /* @__PURE__ */ new Set();
 				let runsInInjectionContextRules = [];
 				return {
 					before() {
-						injectNames.clear();
-						angularNamespaces.clear();
+						injectionContextApiLocalNames.clear();
+						injectionContextApiNamespaceMembers.clear();
 						runsInInjectionContextFunctionNames.clear();
 						runsInInjectionContextRules = (context.options[0] ?? {}).runsInInjectionContext ?? DEFAULT_RUNS_IN_INJECTION_CONTEXT;
 					},
@@ -1121,10 +2417,10 @@ const plugin = eslintCompatPlugin({
 							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);
 						}
-						if (source !== "@angular/core") return;
-						for (const specifier of node.specifiers ?? []) {
-							if (specifier.type === "ImportSpecifier" && getPropertyName(specifier.imported) === "inject") injectNames.add(specifier.local.name);
-							if (specifier.type === "ImportNamespaceSpecifier") angularNamespaces.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) {
@@ -1134,14 +2430,14 @@ const plugin = eslintCompatPlugin({
 						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(node, injectNames, injectFunctionPrefixes, injectFunctionSuffixes, runsInInjectionContextFunctionNames) && !inAllowedContext) {
+						if (isInjectLikeHelperCall(context, node, injectionContextApiLocalNames, injectFunctionPrefixes, injectFunctionSuffixes, runsInInjectionContextFunctionNames) && !inAllowedContext) {
 							context.report({
 								node: node.callee,
 								messageId: "disallowedInject"
 							});
 							return;
 						}
-						if (!isAngularInjectCall(node, injectNames, angularNamespaces, checkUnimportedInject)) return;
+						if (!isKnownInjectionContextApiCall(context, node, injectionContextApiLocalNames, injectionContextApiNamespaceMembers, checkUnimportedInject)) return;
 						if (inAllowedContext) return;
 						context.report({
 							node: node.callee,