@benjavicente/lint-angular 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -23,6 +23,168 @@ 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 addAngularCoreDecoratorImport(specifier, decoratorNames, imports) {
+	if (specifier.type === "ImportSpecifier") {
+		const importedName = getPropertyName(specifier.imported);
+		if (importedName && decoratorNames.has(importedName)) imports.decoratorLocalNames.add(specifier.local.name);
+	}
+	if (specifier.type === "ImportNamespaceSpecifier") imports.angularNamespaces.add(specifier.local.name);
+}
+function isAngularCoreDecorator(context, decorator, imports) {
+	if (!decorator) return false;
+	const expression = decorator.expression ?? decorator;
+	const callee = expression?.type === "CallExpression" ? expression.callee : expression;
+	if (callee?.type === "Identifier") return imports.decoratorLocalNames.has(callee.name) && !isShadowedIdentifier(context, callee);
+	return callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && imports.angularNamespaces.has(callee.object.name) && !isShadowedIdentifier(context, callee.object) && imports.decoratorNames.has(getPropertyName(callee.property) ?? "");
+}
 //#endregion
 //#region src/rules/class-member-order/index.ts
 const ANGULAR_CLASS_DECORATOR_NAMES$1 = new Set([
@@ -45,38 +207,141 @@ const ORDER_LABELS = [
 	"outputs",
 	"everything else"
 ];
-function hasAngularClassDecorator(classNode) {
+function hasAngularClassDecorator(context, classNode, imports) {
 	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, imports));
 }
-function getCallName(node) {
-	if (!node || node.type !== "CallExpression") return null;
+function isApiCall(context, node, localNames, angularNamespaces, 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 (callee?.type === "Identifier") return localNames.has(callee.name) && !isShadowedIdentifier(context, callee);
+	if (callee?.type !== "MemberExpression") return false;
+	const supportsRequiredApi = [...INPUT_MODEL_CALL_NAMES].some((name) => apiNames.has(name));
+	if (callee.object?.type === "Identifier") {
+		if (getPropertyName(callee.property) === "required") return supportsRequiredApi && localNames.has(callee.object.name) && !isShadowedIdentifier(context, callee.object);
+		return angularNamespaces.has(callee.object.name) && !isShadowedIdentifier(context, callee.object) && apiNames.has(getPropertyName(callee.property) ?? "");
+	}
+	if (getPropertyName(callee.property) === "required" && callee.object?.type === "MemberExpression" && callee.object.object?.type === "Identifier") return supportsRequiredApi && angularNamespaces.has(callee.object.object.name) && !isShadowedIdentifier(context, callee.object.object) && apiNames.has(getPropertyName(callee.object.property) ?? "");
+	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, localNames, angularNamespaces, decoratorNames) {
+	return Array.isArray(element.decorators) ? element.decorators.some((decorator) => {
+		const expression = decorator.expression ?? decorator;
+		const callee = expression?.type === "CallExpression" ? expression.callee : expression;
+		if (callee?.type === "Identifier") return localNames.has(callee.name) && !isShadowedIdentifier(context, callee);
+		return callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && angularNamespaces.has(callee.object.name) && !isShadowedIdentifier(context, callee.object) && decoratorNames.has(getPropertyName(callee.property) ?? "");
+	}) : false;
 }
-function classifyMember(element) {
+function classifyMember(context, element, imports) {
 	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, imports.injectLocalNames, imports.angularNamespaces, new Set(["inject"]))) return 0;
+		if (isApiCall(context, element.value, imports.inputModelLocalNames, imports.angularNamespaces, INPUT_MODEL_CALL_NAMES)) return 1;
+		if (hasDecorator(context, element, imports.inputModelDecoratorLocalNames, imports.angularNamespaces, new Set(["Input"]))) return 1;
+		if (isApiCall(context, element.value, imports.outputLocalNames, imports.angularNamespaces, OUTPUT_CALL_NAMES)) return 2;
+		if (hasDecorator(context, element, imports.outputDecoratorLocalNames, imports.angularNamespaces, new Set(["Output"]))) return 2;
 		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,30 +349,88 @@ 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;
-			let highestSeen = null;
-			for (const element of node.body ?? []) {
-				const group = classifyMember(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]
-						}
+		const imports = {
+			decoratorNames: ANGULAR_CLASS_DECORATOR_NAMES$1,
+			decoratorLocalNames: /* @__PURE__ */ new Set(),
+			injectLocalNames: /* @__PURE__ */ new Set(),
+			inputModelLocalNames: /* @__PURE__ */ new Set(),
+			inputModelDecoratorLocalNames: /* @__PURE__ */ new Set(),
+			outputLocalNames: /* @__PURE__ */ new Set(),
+			outputDecoratorLocalNames: /* @__PURE__ */ new Set(),
+			angularNamespaces: /* @__PURE__ */ new Set()
+		};
+		return {
+			before() {
+				imports.decoratorLocalNames.clear();
+				imports.injectLocalNames.clear();
+				imports.inputModelLocalNames.clear();
+				imports.inputModelDecoratorLocalNames.clear();
+				imports.outputLocalNames.clear();
+				imports.outputDecoratorLocalNames.clear();
+				imports.angularNamespaces.clear();
+			},
+			ImportDeclaration(node) {
+				if (node.source?.value !== "@angular/core") return;
+				for (const specifier of node.specifiers ?? []) {
+					addAngularCoreDecoratorImport(specifier, ANGULAR_CLASS_DECORATOR_NAMES$1, imports);
+					if (specifier.type === "ImportSpecifier") {
+						const importedName = getPropertyName(specifier.imported);
+						if (importedName === "inject") imports.injectLocalNames.add(specifier.local.name);
+						if (importedName && INPUT_MODEL_CALL_NAMES.has(importedName)) imports.inputModelLocalNames.add(specifier.local.name);
+						if (importedName === "Input") imports.inputModelDecoratorLocalNames.add(specifier.local.name);
+						if (importedName && OUTPUT_CALL_NAMES.has(importedName)) imports.outputLocalNames.add(specifier.local.name);
+						if (importedName === "Output") imports.outputDecoratorLocalNames.add(specifier.local.name);
+					}
+					if (specifier.type === "ImportNamespaceSpecifier") imports.angularNamespaces.add(specifier.local.name);
+				}
+			},
+			ClassBody(node) {
+				const classBody = node;
+				if (!hasAngularClassDecorator(context, classBody.parent, imports)) return;
+				let highestSeen = null;
+				const classifiedMembers = [];
+				const outOfOrderReports = [];
+				for (const element of classBody.body ?? []) {
+					const group = classifyMember(context, element, imports);
+					if (group === null) continue;
+					classifiedMembers.push({
+						element,
+						group,
+						effectiveGroup: group,
+						name: getMemberName$1(element.key),
+						dependencies: collectThisMemberReferences(element.value)
 					});
-					continue;
 				}
-				highestSeen = group;
+				applyDependencyGroups(classifiedMembers);
+				for (const { element, effectiveGroup } of classifiedMembers) {
+					if (highestSeen !== null && effectiveGroup < highestSeen) {
+						outOfOrderReports.push({
+							element,
+							effectiveGroup,
+							previousEffectiveGroup: highestSeen
+						});
+						continue;
+					}
+					highestSeen = effectiveGroup;
+				}
+				if (!outOfOrderReports.length) return;
+				const fix = getSortedMembersFix(context, classBody, classifiedMembers);
+				for (const [index, report] of outOfOrderReports.entries()) context.report({
+					node: report.element,
+					messageId: "outOfOrder",
+					data: {
+						expectedGroup: ORDER_LABELS[report.effectiveGroup],
+						previousGroup: ORDER_LABELS[report.previousEffectiveGroup]
+					},
+					fix: index === 0 ? fix : void 0
+				});
 			}
-		} };
+		};
 	}
 });
 //#endregion
@@ -115,24 +438,24 @@ 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 isAngularNamespaceMember(context, node, namespaces, memberName) {
+	return node?.type === "MemberExpression" && node.object?.type === "Identifier" && namespaces.has(node.object.name) && !isShadowedIdentifier(context, node.object) && getPropertyName(node.property) === memberName;
 }
-function isInjectCall(callNode, injectNames, angularNamespaces) {
+function isInjectCall(context, callNode, injectNames, angularNamespaces) {
 	const callee = callNode.callee;
-	return callee?.type === "Identifier" && injectNames.has(callee.name) || isAngularNamespaceMember(callee, angularNamespaces, "inject");
+	return callee?.type === "Identifier" && injectNames.has(callee.name) && !isShadowedIdentifier(context, callee) || isAngularNamespaceMember(context, callee, angularNamespaces, "inject");
 }
-function isInjectorReference(node, injectorNames, angularNamespaces) {
-	return node?.type === "Identifier" && injectorNames.has(node.name) || isAngularNamespaceMember(node, angularNamespaces, "Injector");
+function isInjectorReference(context, node, injectorNames, angularNamespaces) {
+	return node?.type === "Identifier" && injectorNames.has(node.name) && !isShadowedIdentifier(context, node) || isAngularNamespaceMember(context, node, angularNamespaces, "Injector");
 }
-function isDisallowedInjectInjector(callNode, injectNames, injectorNames, angularNamespaces) {
-	if (!isInjectCall(callNode, injectNames, angularNamespaces)) return false;
-	return isInjectorReference(callNode.arguments?.[0], injectorNames, angularNamespaces);
+function isDisallowedInjectInjector(context, callNode, injectNames, injectorNames, angularNamespaces) {
+	if (!isInjectCall(context, callNode, injectNames, angularNamespaces)) return false;
+	return isInjectorReference(context, callNode.arguments?.[0], injectorNames, angularNamespaces);
 }
-function isDisallowedRunInInjectionContext(callNode, runInInjectionContextNames, runInContextNames, angularNamespaces) {
+function isDisallowedRunInInjectionContext(context, callNode, runInInjectionContextNames, runInContextNames, angularNamespaces) {
 	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) ?? "");
+	if (callee?.type === "Identifier") return (runInInjectionContextNames.has(callee.name) || runInContextNames.has(callee.name)) && !isShadowedIdentifier(context, callee);
+	if (callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && angularNamespaces.has(callee.object.name) && !isShadowedIdentifier(context, callee.object)) return RUN_IN_INJECTION_CONTEXT_NAMES.has(getPropertyName(callee.property) ?? "");
 	return false;
 }
 const avoidExplicitInjectionContext = defineRule({
@@ -193,11 +516,11 @@ const avoidExplicitInjectionContext = defineRule({
 				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({
+				if (disallowInjectInjector && isDisallowedInjectInjector(context, callNode, injectNames, injectorNames, angularNamespaces)) context.report({
 					node: callNode.callee,
 					messageId: "avoidInjectInjector"
 				});
-				if (disallowRunInInjectionContext && isDisallowedRunInInjectionContext(callNode, runInInjectionContextNames, runInContextNames, angularNamespaces)) context.report({
+				if (disallowRunInInjectionContext && isDisallowedRunInInjectionContext(context, callNode, runInInjectionContextNames, runInContextNames, angularNamespaces)) context.report({
 					node: callNode.callee,
 					messageId: "avoidRunInInjectionContext"
 				});
@@ -206,13 +529,391 @@ const avoidExplicitInjectionContext = defineRule({
 	}
 });
 //#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$2(context, classNode, decoratorImports) {
+	if (!classNode || !Array.isArray(classNode.decorators)) return false;
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, decoratorImports));
+}
+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();
+		const decoratorImports = {
+			decoratorNames: TARGET_DECORATORS$2,
+			decoratorLocalNames: /* @__PURE__ */ new Set(),
+			angularNamespaces: /* @__PURE__ */ new Set()
+		};
+		return {
+			before() {
+				subscriptionLocalNames.clear();
+				rxjsSubscribableLocalNames.clear();
+				rxjsNamespaces.clear();
+				takeUntilDestroyedLocalNames.clear();
+				interopNamespaces.clear();
+				decoratorImports.decoratorLocalNames.clear();
+				decoratorImports.angularNamespaces.clear();
+			},
+			ImportDeclaration(node) {
+				const source = node.source?.value;
+				if (source === "@angular/core") for (const specifier of node.specifiers ?? []) addAngularCoreDecoratorImport(specifier, TARGET_DECORATORS$2, decoratorImports);
+				if (source === "rxjs") for (const specifier of node.specifiers ?? []) {
+					if (specifier.type === "ImportSpecifier") {
+						const importedName = getPropertyName(specifier.imported);
+						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") interopNamespaces.add(specifier.local.name);
+				}
+			},
+			ClassBody(node) {
+				const classBody = node;
+				const classNode = classBody.parent;
+				if (!classNode || !hasTargetDecorator$2(context, classNode, decoratorImports)) 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;
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
 //#region src/rules/avoid-ng-modules/index.ts
 const DEFAULT_ALLOW_FOR_GROUPING = true;
 const DEFAULT_ALLOW_FOR_PROVIDING = false;
 const DEFAULT_ALLOW_FOR_ROUTING = false;
-function getNgModuleMetadata(node) {
-	if (node.type !== "Decorator") return null;
-	if (getDecoratorName(node) !== "NgModule") return null;
+function isNgModuleDecorator(context, node, importBindings, namespaceImportBindings) {
+	if (node.type !== "Decorator") return false;
+	const expression = node.expression ?? node;
+	const callee = expression?.type === "CallExpression" ? expression.callee : expression;
+	if (callee?.type === "Identifier") {
+		const binding = importBindings.get(callee.name);
+		return !!binding && binding.source === "@angular/core" && binding.importedName === "NgModule" && !isShadowedIdentifier(context, callee);
+	}
+	return callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && namespaceImportBindings.get(callee.object.name) === "@angular/core" && !isShadowedIdentifier(context, callee.object) && getPropertyName(callee.property) === "NgModule";
+}
+function getNgModuleMetadata(context, node, importBindings, namespaceImportBindings) {
+	if (!isNgModuleDecorator(context, node, importBindings, namespaceImportBindings)) return null;
 	const expression = node.expression;
 	if (expression?.type !== "CallExpression") return null;
 	const metadata = expression.arguments?.[0];
@@ -226,8 +927,19 @@ 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(node, expectedSource, expectedModuleName, importBindings, namespaceImportBindings) {
+	if (node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	if (callee?.type !== "MemberExpression") return false;
+	const moduleRef = callee.object;
+	if (moduleRef?.type === "Identifier") {
+		const binding = importBindings.get(moduleRef.name);
+		return !!binding && binding.source === expectedSource && binding.importedName === expectedModuleName;
+	}
+	if (moduleRef?.type !== "MemberExpression") return false;
+	if (moduleRef.object?.type !== "Identifier") return false;
+	if (namespaceImportBindings.get(moduleRef.object.name) !== expectedSource) return false;
+	return getPropertyName(moduleRef.property) === expectedModuleName;
 }
 function getNgModuleClassNode(decoratorNode) {
 	const parent = decoratorNode.parent;
@@ -264,48 +976,342 @@ 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) {
+		const importBindings = /* @__PURE__ */ new Map();
+		const namespaceImportBindings = /* @__PURE__ */ new Map();
+		return {
+			before() {
+				importBindings.clear();
+				namespaceImportBindings.clear();
+			},
+			ImportDeclaration(node) {
+				const source = node.source?.value;
+				if (typeof source !== "string") return;
+				for (const specifier of node.specifiers ?? []) {
+					if (specifier.type === "ImportSpecifier") {
+						const importedName = getPropertyName(specifier.imported);
+						if (!importedName) continue;
+						importBindings.set(specifier.local.name, {
+							source,
+							importedName
+						});
+						continue;
+					}
+					if (specifier.type === "ImportNamespaceSpecifier") namespaceImportBindings.set(specifier.local.name, source);
+				}
+			},
+			Decorator(node) {
+				const options = context.options[0] ?? {};
+				const allowForGrouping = options.allowForGrouping ?? DEFAULT_ALLOW_FOR_GROUPING;
+				const allowForProviding = options.allowForProviding ?? DEFAULT_ALLOW_FOR_PROVIDING;
+				const allowForRouting = options.allowForRouting ?? DEFAULT_ALLOW_FOR_ROUTING;
+				const metadata = getNgModuleMetadata(context, node, importBindings, namespaceImportBindings);
+				if (!metadata) return;
+				const importsElements = getArrayElementsFromProperty(metadata, "imports");
+				const exportsElements = getArrayElementsFromProperty(metadata, "exports");
+				if (!allowForGrouping && (importsElements.length > 0 || exportsElements.length > 0)) context.report({
+					node,
+					messageId: "avoidModuleImportsExports"
+				});
+				const importCalls = importsElements.filter((element) => element.type === "CallExpression");
+				if (!allowForProviding) {
+					for (const call of importCalls) {
+						const methodName = getPropertyName(call.callee?.property);
+						if (methodName === "forRoot" && isModuleCallFromImport(call, "@angular/router", "RouterModule", importBindings, namespaceImportBindings) && !allowForRouting) {
+							context.report({
+								node: call,
+								messageId: "avoidRouterForRoot"
+							});
+							continue;
+						}
+						if (methodName === "forRoot" && isModuleCallFromImport(call, "@ngrx/store", "StoreModule", importBindings, namespaceImportBindings)) {
+							context.report({
+								node: call,
+								messageId: "avoidNgrxStoreForRoot"
+							});
+							continue;
+						}
+						if (methodName === "forRoot" && isModuleCallFromImport(call, "@ngrx/effects", "EffectsModule", importBindings, namespaceImportBindings)) {
+							context.report({
+								node: call,
+								messageId: "avoidNgrxEffectsForRoot"
+							});
+							continue;
+						}
+						if (methodName === "forFeature" && isModuleCallFromImport(call, "@ngrx/store", "StoreModule", importBindings, namespaceImportBindings)) {
+							context.report({
+								node: call,
+								messageId: "avoidNgrxStoreForFeature"
+							});
+							continue;
+						}
+						if (methodName === "forFeature" && isModuleCallFromImport(call, "@ngrx/effects", "EffectsModule", importBindings, namespaceImportBindings)) {
+							context.report({
+								node: call,
+								messageId: "avoidNgrxEffectsForFeature"
+							});
+							continue;
+						}
+						if (methodName === "instrument" && isModuleCallFromImport(call, "@ngrx/store-devtools", "StoreDevtoolsModule", importBindings, namespaceImportBindings)) {
+							context.report({
+								node: call,
+								messageId: "avoidNgrxStoreDevtoolsInstrument"
+							});
+							continue;
+						}
+						if (methodName === "forRoot" && isModuleCallFromImport(call, "@ngrx/router-store", "StoreRouterConnectingModule", importBindings, namespaceImportBindings)) {
+							context.report({
+								node: call,
+								messageId: "avoidNgrxRouterStoreForRoot"
+							});
+							continue;
+						}
+						if (methodName === "forRoot" && isModuleCallFromImport(call, "@angular/router", "RouterModule", importBindings, namespaceImportBindings) && allowForRouting) continue;
+						if (!isMemberCall(call, "forRoot")) continue;
+						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(call, "@angular/router", "RouterModule", importBindings, namespaceImportBindings)) 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$1(context, classNode, decoratorImports) {
+	if (!classNode || !Array.isArray(classNode.decorators)) return false;
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, decoratorImports));
+}
+function getImportedSubjectKind(localName, subjectLocalNames) {
+	return subjectLocalNames.get(localName) ?? null;
+}
+function getSubjectKindFromType(context, node, subjectLocalNames, rxjsNamespaces) {
+	if (!node) return null;
+	if (node.type !== "TSTypeReference") return null;
+	const typeName = getTypeName(node.typeName);
+	if (!typeName) return null;
+	const localKind = getImportedSubjectKind(typeName, subjectLocalNames);
+	if (localKind && node.typeName?.type === "Identifier" && !isShadowedIdentifier(context, node.typeName)) return localKind;
+	if (!typeName.includes(".")) return null;
+	const [namespaceName, memberName] = typeName.split(".");
+	if (!rxjsNamespaces.has(namespaceName)) return null;
+	if (node.typeName?.type === "TSQualifiedName" && node.typeName.left?.type === "Identifier" && isShadowedIdentifier(context, node.typeName.left)) return null;
+	return SUBJECT_NAMES.has(memberName) ? memberName : null;
+}
+function getSubjectKindFromConstructor(context, node, subjectLocalNames, rxjsNamespaces) {
+	const expression = unwrapExpression(node);
+	if (expression?.type !== "NewExpression") return null;
+	const callee = unwrapExpression(expression.callee);
+	if (callee?.type === "Identifier") {
+		if (isShadowedIdentifier(context, callee)) return null;
+		return getImportedSubjectKind(callee.name, subjectLocalNames);
+	}
+	if (callee?.type !== "MemberExpression") return null;
+	if (callee.object?.type !== "Identifier" || !rxjsNamespaces.has(callee.object.name)) return null;
+	if (isShadowedIdentifier(context, callee.object)) 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, subjectLocalNames, rxjsNamespaces) {
+	const fields = /* @__PURE__ */ new Map();
+	for (const member of classBody.body ?? []) {
+		if (!FIELD_NODE_TYPES$1.has(member.type)) continue;
+		const fieldName = getMemberName(member.key);
+		if (!fieldName) continue;
+		const typeNode = member.typeAnnotation?.typeAnnotation;
+		const kind = getSubjectKindFromConstructor(context, member.value, subjectLocalNames, rxjsNamespaces) ?? getSubjectKindFromType(context, typeNode, subjectLocalNames, rxjsNamespaces);
+		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;
+		const subjectLocalNames = /* @__PURE__ */ new Map();
+		const rxjsNamespaces = /* @__PURE__ */ new Set();
+		const decoratorImports = {
+			decoratorNames: TARGET_DECORATORS$1,
+			decoratorLocalNames: /* @__PURE__ */ new Set(),
+			angularNamespaces: /* @__PURE__ */ new Set()
+		};
+		return {
+			before() {
+				subjectLocalNames.clear();
+				rxjsNamespaces.clear();
+				decoratorImports.decoratorLocalNames.clear();
+				decoratorImports.angularNamespaces.clear();
+			},
+			ImportDeclaration(node) {
+				if (node.source?.value === "@angular/core") {
+					for (const specifier of node.specifiers ?? []) addAngularCoreDecoratorImport(specifier, TARGET_DECORATORS$1, decoratorImports);
+					return;
+				}
+				if (node.source?.value !== "rxjs") return;
+				for (const specifier of node.specifiers ?? []) {
+					if (specifier.type === "ImportSpecifier") {
+						const importedName = getPropertyName(specifier.imported);
+						if (SUBJECT_NAMES.has(importedName)) subjectLocalNames.set(specifier.local.name, importedName);
+						continue;
+					}
+					if (specifier.type === "ImportNamespaceSpecifier") rxjsNamespaces.add(specifier.local.name);
+				}
+			},
+			ClassBody(node) {
+				const classBody = node;
+				const classNode = classBody.parent;
+				if (!hasTargetDecorator$1(context, classNode, decoratorImports)) return;
+				const fields = collectSubjectFields(context, classBody, subjectLocalNames, rxjsNamespaces);
+				const usages = collectFieldUsages(classBody, fields);
+				for (const [fieldName, field] of fields) {
+					const usage = usages.get(fieldName);
+					if (field.kind === "Subject" && isDestroySubjectUsage(usage)) {
+						context.report({
+							node: field.key,
+							messageId: "avoidDestroySubject"
+						});
+						continue;
+					}
 					context.report({
-						node: call,
-						messageId: "avoidForRoot"
+						node: field.key,
+						messageId: "avoidRxjsState",
+						data: { kind: field.kind }
 					});
 				}
-				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"
-				});
 			}
-		} };
+		};
 	}
 });
 //#endregion
@@ -323,38 +1329,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 isAngularCoreNamespaceMember(context, node, angularNamespaces, memberName) {
+	return node?.type === "MemberExpression" && node.object?.type === "Identifier" && angularNamespaces.has(node.object.name) && !isShadowedIdentifier(context, node.object) && getPropertyName(node.property) === memberName;
 }
-function isSignalCreatorCall(node, signalCreatorNames, angularNamespaces) {
+function isSignalCreatorCall(context, node, signalCreatorNames, angularNamespaces) {
 	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 callee?.type === "Identifier" && signalCreatorNames.has(callee.name) && !isShadowedIdentifier(context, callee) || [...KNOWN_SIGNAL_CREATION_FUNCTIONS].some((name) => isAngularCoreNamespaceMember(context, callee, angularNamespaces, name));
 }
-function isEffectCall(node, effectNames, angularNamespaces) {
+function isEffectCall(context, node, effectNames, angularNamespaces) {
 	const callee = node.callee;
-	return callee?.type === "Identifier" && effectNames.has(callee.name) || isAngularCoreNamespaceMember(callee, angularNamespaces, "effect");
+	return callee?.type === "Identifier" && effectNames.has(callee.name) && !isShadowedIdentifier(context, callee) || isAngularCoreNamespaceMember(context, callee, angularNamespaces, "effect");
 }
-function isReactiveCreatorCall(node, creatorNames, angularNamespaces, angularMemberName) {
+function isReactiveCreatorCall(context, node, creatorNames, angularNamespaces, angularMemberName) {
 	const callee = node.callee;
-	return callee?.type === "Identifier" && creatorNames.has(callee.name) || isAngularCoreNamespaceMember(callee, angularNamespaces, angularMemberName);
+	return callee?.type === "Identifier" && creatorNames.has(callee.name) && !isShadowedIdentifier(context, callee) || isAngularCoreNamespaceMember(context, callee, angularNamespaces, angularMemberName);
 }
-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({
@@ -386,7 +1403,7 @@ const avoidWritingSignalsInReactiveContext = defineRule({
 		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() {
@@ -395,7 +1412,7 @@ const avoidWritingSignalsInReactiveContext = defineRule({
 				linkedSignalNames.clear();
 				signalCreatorNames.clear();
 				angularNamespaces.clear();
-				signalVariables.clear();
+				signalVariableBindings.clear();
 				classSignalProperties.clear();
 			},
 			ImportDeclaration(node) {
@@ -414,13 +1431,15 @@ const avoidWritingSignalsInReactiveContext = defineRule({
 			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, signalCreatorNames, angularNamespaces)) 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, signalCreatorNames, angularNamespaces)) return;
 				classSignalProperties.add(property.key.name);
 			},
 			CallExpression(node) {
@@ -429,21 +1448,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, effectNames, angularNamespaces)) {
 					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, computedNames, angularNamespaces, COMPUTED_CREATOR_NAME)) {
 					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, linkedSignalNames, angularNamespaces, LINKED_SIGNAL_CREATOR_NAME)) for (const argumentNode of callNode.arguments ?? []) {
 					const argument = argumentNode;
 					if (argument.type === "ArrowFunctionExpression" || argument.type === "FunctionExpression") {
 						callbackCandidates.push({
@@ -464,27 +1483,27 @@ 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"() {
+			after() {
 				effectNames.clear();
 				computedNames.clear();
 				linkedSignalNames.clear();
 				signalCreatorNames.clear();
 				angularNamespaces.clear();
-				signalVariables.clear();
+				signalVariableBindings.clear();
 				classSignalProperties.clear();
 			}
 		};
@@ -492,6 +1511,7 @@ const avoidWritingSignalsInReactiveContext = defineRule({
 });
 //#endregion
 //#region src/rules/component-class-matches-filename/index.ts
+const COMPONENT_DECORATORS$1 = new Set(["Component"]);
 function toPascalCase(raw) {
 	return raw.split(/[-_\s.]+/u).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
 }
@@ -514,20 +1534,33 @@ const componentClassMatchesFilename = defineRule({
 		messages: { classNameMismatch: "Component class name should be '{{expectedName}}' to match the filename '{{filename}}'." }
 	},
 	createOnce(context) {
-		const classDeclarations = [];
+		const componentClasses = [];
+		const decoratorImports = {
+			decoratorNames: COMPONENT_DECORATORS$1,
+			decoratorLocalNames: /* @__PURE__ */ new Set(),
+			angularNamespaces: /* @__PURE__ */ new Set()
+		};
 		return {
 			before() {
-				classDeclarations.length = 0;
+				componentClasses.length = 0;
+				decoratorImports.decoratorLocalNames.clear();
+				decoratorImports.angularNamespaces.clear();
+			},
+			ImportDeclaration(node) {
+				if (node.source?.value !== "@angular/core") return;
+				for (const specifier of node.specifiers ?? []) addAngularCoreDecoratorImport(specifier, COMPONENT_DECORATORS$1, decoratorImports);
 			},
 			ClassDeclaration(node) {
-				classDeclarations.push(node);
+				const classNode = node;
+				if (!Array.isArray(classNode.decorators)) return;
+				if (classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, decoratorImports))) componentClasses.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];
+				const classNode = componentClasses.find((candidate) => candidate.parent?.type === "ExportNamedDeclaration" || candidate.parent?.type === "ExportDefaultDeclaration") ?? null ?? componentClasses[0];
 				if (!classNode?.id?.name) return;
 				if (classNode.id.name === expectedName) return;
 				context.report({
@@ -543,13 +1576,158 @@ const componentClassMatchesFilename = defineRule({
 	}
 });
 //#endregion
+//#region src/rules/component-resource-filenames/index.ts
+const COMPONENT_DECORATORS = 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, decoratorImports) {
+	if (node.type !== "Decorator") return null;
+	if (!isAngularCoreDecorator(context, node, decoratorImports)) 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) {
+		const decoratorImports = {
+			decoratorNames: COMPONENT_DECORATORS,
+			decoratorLocalNames: /* @__PURE__ */ new Set(),
+			angularNamespaces: /* @__PURE__ */ new Set()
+		};
+		function reportTemplateUrl(valueNode) {
+			const expectedStem = getExpectedStem(context.filename ?? "");
+			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) {
+			const expectedStem = getExpectedStem(context.filename ?? "");
+			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() {
+				decoratorImports.decoratorLocalNames.clear();
+				decoratorImports.angularNamespaces.clear();
+			},
+			ImportDeclaration(node) {
+				if (node.source?.value !== "@angular/core") return;
+				for (const specifier of node.specifiers ?? []) addAngularCoreDecoratorImport(specifier, COMPONENT_DECORATORS, decoratorImports);
+			},
+			Decorator(node) {
+				const metadata = getComponentMetadata(context, node, decoratorImports);
+				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/prefer-load-component-over-load-children/index.ts
-function isRoutesTypeAnnotation(node) {
+function isImportedTypeName(typeNode, localNames, routerNamespaces) {
+	const typeName = getTypeName(typeNode);
+	if (!typeName) return false;
+	if (!typeName.includes(".")) return localNames.has(typeName);
+	const [namespaceName, memberName] = typeName.split(".");
+	return routerNamespaces.has(namespaceName) && localNames.has(memberName);
+}
+function getTypeParameterNodes(typeNode) {
+	return typeNode.typeParameters?.params ?? typeNode.typeArguments?.params ?? [];
+}
+function isRouteType(typeNode, imports) {
+	return typeNode?.type === "TSTypeReference" && isImportedTypeName(typeNode.typeName, imports.routeTypeLocalNames, imports.routerNamespaces);
+}
+function isRouteArrayType(typeNode, imports) {
+	if (!typeNode) return false;
+	if (typeNode.type === "TSTypeReference" && isImportedTypeName(typeNode.typeName, imports.routesTypeLocalNames, imports.routerNamespaces)) return true;
+	if (typeNode.type === "TSArrayType") return isRouteType(typeNode.elementType, imports);
+	if (typeNode.type !== "TSTypeReference") return false;
+	const typeName = getTypeName(typeNode.typeName);
+	if (typeName !== "Array" && typeName !== "ReadonlyArray") return false;
+	const [elementType] = getTypeParameterNodes(typeNode);
+	return isRouteType(elementType, imports);
+}
+function isRoutesTypeAnnotation(node, imports) {
 	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(typeAnnotation.typeAnnotation, imports);
 }
 function isExportedConstDeclarator(node) {
 	if (node.type !== "VariableDeclarator") return false;
@@ -557,19 +1735,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,21 +1746,58 @@ const preferLoadComponentOverLoadChildren = defineRule({
 		messages: { avoidLoadChildren: "Avoid loadChildren in Routes arrays; prefer loadComponent for lazy-loading standalone route components." }
 	},
 	createOnce(context) {
-		return { VariableDeclarator(node) {
-			const declarator = node;
-			if (!isExportedConstDeclarator(declarator)) return;
-			if (declarator.id?.type !== "Identifier") return;
-			if (!isRoutesTypeAnnotation(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"
-				});
-			});
-		} };
+		const imports = {
+			routeTypeLocalNames: /* @__PURE__ */ new Set(),
+			routesTypeLocalNames: /* @__PURE__ */ new Set(),
+			routerNamespaces: /* @__PURE__ */ new Set()
+		};
+		function reportLoadChildrenInRouteObject(routeObject) {
+			for (const property of routeObject.properties ?? []) {
+				if (property.type !== "Property" || property.computed) continue;
+				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 {
+			before() {
+				imports.routeTypeLocalNames.clear();
+				imports.routesTypeLocalNames.clear();
+				imports.routerNamespaces.clear();
+			},
+			ImportDeclaration(node) {
+				if (node.source?.value !== "@angular/router") return;
+				for (const specifier of node.specifiers ?? []) {
+					if (specifier.type === "ImportSpecifier") {
+						const importedName = getPropertyName(specifier.imported);
+						if (importedName === "Route") imports.routeTypeLocalNames.add(specifier.local.name);
+						if (importedName === "Routes") imports.routesTypeLocalNames.add(specifier.local.name);
+					}
+					if (specifier.type === "ImportNamespaceSpecifier") {
+						imports.routerNamespaces.add(specifier.local.name);
+						imports.routeTypeLocalNames.add("Route");
+						imports.routesTypeLocalNames.add("Routes");
+					}
+				}
+			},
+			VariableDeclarator(node) {
+				const declarator = node;
+				if (!isExportedConstDeclarator(declarator)) return;
+				if (declarator.id?.type !== "Identifier") return;
+				if (!isRoutesTypeAnnotation(declarator.id, imports)) return;
+				if (declarator.init?.type !== "ArrayExpression") return;
+				reportLoadChildrenInRouteArray(declarator.init);
+			}
+		};
 	}
 });
 //#endregion
@@ -604,6 +1806,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 +1960,10 @@ const preferPrivateElements = defineRule({
 });
 //#endregion
 //#region src/rules/prefer-style-url/index.ts
-function isComponentDecoratorCall(node) {
+function isComponentDecoratorCall(context, node, componentLocalNames, angularNamespaces) {
 	const callee = node.callee;
-	if (callee?.type === "Identifier") return callee.name === "Component";
-	return callee?.type === "MemberExpression" && getPropertyName(callee.property) === "Component";
+	if (callee?.type === "Identifier") return componentLocalNames.has(callee.name) && !isShadowedIdentifier(context, callee);
+	return callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && angularNamespaces.has(callee.object.name) && !isShadowedIdentifier(context, callee.object) && getPropertyName(callee.property) === "Component";
 }
 function isSingleStyleFileNode(node) {
 	if (!node) return false;
@@ -779,38 +1982,203 @@ const preferStyleUrl = defineRule({
 		messages: { preferStyleUrl: "Use styleUrl instead of styleUrls when a component has one style file." }
 	},
 	createOnce(context) {
-		return { CallExpression(node) {
-			const call = node;
-			if (!isComponentDecoratorCall(call)) return;
-			const metadata = call.arguments?.[0];
-			if (metadata?.type !== "ObjectExpression") return;
-			for (const property of metadata.properties ?? []) {
-				if (property.type !== "Property") continue;
-				if (property.computed) continue;
-				if (getPropertyName(property.key) !== "styleUrls") continue;
-				if (property.value?.type !== "ArrayExpression") continue;
-				const elements = property.value.elements?.filter(Boolean) ?? [];
-				if (elements.length !== 1) continue;
-				const styleFile = elements[0];
-				if (!isSingleStyleFileNode(styleFile)) continue;
-				const keyRange = getRange(property.key);
-				const valueRange = getRange(property.value);
-				const styleFileRange = getRange(styleFile);
-				context.report({
-					node: property.key,
-					messageId: "preferStyleUrl",
-					fix: keyRange && valueRange && styleFileRange ? (fixer) => [fixer.replaceTextRange(keyRange, "styleUrl"), fixer.replaceTextRange(valueRange, context.sourceCode.text.slice(styleFileRange[0], styleFileRange[1]))] : void 0
-				});
+		const componentLocalNames = /* @__PURE__ */ new Set();
+		const angularNamespaces = /* @__PURE__ */ new Set();
+		return {
+			before() {
+				componentLocalNames.clear();
+				angularNamespaces.clear();
+			},
+			ImportDeclaration(node) {
+				if (node.source?.value !== "@angular/core") return;
+				for (const specifier of node.specifiers ?? []) {
+					if (specifier.type === "ImportSpecifier") {
+						if (getPropertyName(specifier.imported) === "Component") componentLocalNames.add(specifier.local.name);
+					}
+					if (specifier.type === "ImportNamespaceSpecifier") angularNamespaces.add(specifier.local.name);
+				}
+			},
+			CallExpression(node) {
+				const call = node;
+				if (!isComponentDecoratorCall(context, call, componentLocalNames, angularNamespaces)) return;
+				const metadata = call.arguments?.[0];
+				if (metadata?.type !== "ObjectExpression") return;
+				for (const property of metadata.properties ?? []) {
+					if (property.type !== "Property") continue;
+					if (property.computed) continue;
+					if (getPropertyName(property.key) !== "styleUrls") continue;
+					if (property.value?.type !== "ArrayExpression") continue;
+					const elements = property.value.elements?.filter(Boolean) ?? [];
+					if (elements.length !== 1) continue;
+					const styleFile = elements[0];
+					if (!isSingleStyleFileNode(styleFile)) continue;
+					const keyRange = getRange(property.key);
+					const valueRange = getRange(property.value);
+					const styleFileRange = getRange(styleFile);
+					context.report({
+						node: property.key,
+						messageId: "preferStyleUrl",
+						fix: keyRange && valueRange && styleFileRange ? (fixer) => [fixer.replaceTextRange(keyRange, "styleUrl"), fixer.replaceTextRange(valueRange, context.sourceCode.text.slice(styleFileRange[0], styleFileRange[1]))] : void 0
+					});
+				}
 			}
-		} };
+		};
+	}
+});
+//#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, decoratorImports) {
+	if (!classNode || !Array.isArray(classNode.decorators)) return false;
+	return classNode.decorators.some((decorator) => isAngularCoreDecorator(context, decorator, decoratorImports));
+}
+function isApiCallFromTrackedImports(context, node, importedApiLocalNames, angularNamespaces, apiNames) {
+	if (!node || node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	if (callee?.type === "Identifier") return importedApiLocalNames.has(callee.name) && !isShadowedIdentifier(context, callee);
+	if (callee?.type !== "MemberExpression") return false;
+	const supportsRequiredApi = [...INPUT_MODEL_APIS].some((name) => apiNames.has(name));
+	if (getPropertyName(callee.property) === "required" && callee.object?.type === "Identifier") return supportsRequiredApi && importedApiLocalNames.has(callee.object.name) && !isShadowedIdentifier(context, callee.object);
+	if (callee.object?.type === "Identifier" && angularNamespaces.has(callee.object.name)) {
+		const namespaceApiName = getPropertyName(callee.property);
+		return !!namespaceApiName && apiNames.has(namespaceApiName) && !isShadowedIdentifier(context, callee.object);
+	}
+	if (getPropertyName(callee.property) === "required" && callee.object?.type === "MemberExpression" && callee.object.object?.type === "Identifier" && angularNamespaces.has(callee.object.object.name)) {
+		const namespaceApiName = getPropertyName(callee.object.property);
+		return supportsRequiredApi && !!namespaceApiName && apiNames.has(namespaceApiName) && !isShadowedIdentifier(context, callee.object.object);
+	}
+	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) {
+		const inputModelLocalNames = /* @__PURE__ */ new Set();
+		const outputLocalNames = /* @__PURE__ */ new Set();
+		const injectLocalNames = /* @__PURE__ */ new Set();
+		const angularNamespaces = /* @__PURE__ */ new Set();
+		const decoratorImports = {
+			decoratorNames: TARGET_DECORATORS,
+			decoratorLocalNames: /* @__PURE__ */ new Set(),
+			angularNamespaces
+		};
+		return {
+			before() {
+				inputModelLocalNames.clear();
+				outputLocalNames.clear();
+				injectLocalNames.clear();
+				angularNamespaces.clear();
+				decoratorImports.decoratorLocalNames.clear();
+			},
+			ImportDeclaration(node) {
+				if (node.source?.value !== "@angular/core") return;
+				for (const specifier of node.specifiers ?? []) {
+					addAngularCoreDecoratorImport(specifier, TARGET_DECORATORS, decoratorImports);
+					if (specifier.type === "ImportSpecifier") {
+						const importedName = getPropertyName(specifier.imported);
+						if (!importedName) continue;
+						if (INPUT_MODEL_APIS.has(importedName)) inputModelLocalNames.add(specifier.local.name);
+						if (OUTPUT_APIS.has(importedName)) outputLocalNames.add(specifier.local.name);
+						if (INJECT_APIS.has(importedName)) injectLocalNames.add(specifier.local.name);
+						continue;
+					}
+					if (specifier.type === "ImportNamespaceSpecifier") angularNamespaces.add(specifier.local.name);
+				}
+			},
+			ClassBody(node) {
+				const classNode = node.parent;
+				if (!hasTargetDecorator(context, classNode, decoratorImports)) return;
+				for (const member of node.body ?? []) {
+					if (!FIELD_NODE_TYPES.has(member.type)) continue;
+					const isInputModelMember = isApiCallFromTrackedImports(context, member.value, inputModelLocalNames, angularNamespaces, INPUT_MODEL_APIS);
+					const isOutputMember = isApiCallFromTrackedImports(context, member.value, outputLocalNames, angularNamespaces, OUTPUT_APIS);
+					if (isInputModelMember && isNonPublicMember(member)) {
+						context.report({
+							node: member.key ?? member,
+							messageId: "nonPublicInputModel",
+							data: { name: getPropertyName(member.key) ?? "member" },
+							fix: getVisibilityFix(context, member, "public")
+						});
+						continue;
+					}
+					if (isOutputMember && isNonPublicMember(member)) {
+						context.report({
+							node: member.key ?? member,
+							messageId: "nonPublicOutput",
+							data: { name: getPropertyName(member.key) ?? "member" },
+							fix: getVisibilityFix(context, member, "public")
+						});
+						continue;
+					}
+					if (isPublicMember(member) && isApiCallFromTrackedImports(context, member.value, injectLocalNames, angularNamespaces, INJECT_APIS)) context.report({
+						node: member.key ?? member,
+						messageId: "publicInjectMember",
+						data: { name: getPropertyName(member.key) ?? "member" },
+						fix: getVisibilityFix(context, member, "protected")
+					});
+				}
+			},
+			"Program:exit"() {
+				inputModelLocalNames.clear();
+				outputLocalNames.clear();
+				injectLocalNames.clear();
+				angularNamespaces.clear();
+			}
+		};
 	}
 });
 //#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, decoratorImports) {
 	if (node.type !== "Decorator") return null;
-	if (getDecoratorName(node) !== "Injectable") return null;
+	if (!isAngularCoreDecorator(context, node, decoratorImports)) return null;
 	const expression = node.expression;
 	if (expression?.type !== "CallExpression") return null;
 	const metadata = expression.arguments?.[0];
@@ -832,23 +2200,38 @@ 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);
-			if (!metadata) return;
-			const providedInProperty = getProvidedInProperty(metadata);
-			if (!providedInProperty) return;
-			const value = providedInProperty.value;
-			if (isAllowedProvidedInValue(value)) return;
-			const actual = context.sourceCode.text.slice(value?.range?.[0] ?? providedInProperty.range?.[0] ?? 0, value?.range?.[1] ?? providedInProperty.range?.[1] ?? 0);
-			context.report({
-				node: value ?? providedInProperty,
-				messageId: "disallowedProvidedIn",
-				data: { actual: actual || "this value" }
-			});
-		} };
+		const decoratorImports = {
+			decoratorNames: INJECTABLE_DECORATORS,
+			decoratorLocalNames: /* @__PURE__ */ new Set(),
+			angularNamespaces: /* @__PURE__ */ new Set()
+		};
+		return {
+			before() {
+				decoratorImports.decoratorLocalNames.clear();
+				decoratorImports.angularNamespaces.clear();
+			},
+			ImportDeclaration(node) {
+				if (node.source?.value !== "@angular/core") return;
+				for (const specifier of node.specifiers ?? []) addAngularCoreDecoratorImport(specifier, INJECTABLE_DECORATORS, decoratorImports);
+			},
+			Decorator(node) {
+				const metadata = getInjectableMetadata(context, node, decoratorImports);
+				if (!metadata) return;
+				const providedInProperty = getProvidedInProperty(metadata);
+				if (!providedInProperty) return;
+				const value = providedInProperty.value;
+				if (isAllowedProvidedInValue(value)) return;
+				const actual = context.sourceCode.text.slice(value?.range?.[0] ?? providedInProperty.range?.[0] ?? 0, value?.range?.[1] ?? providedInProperty.range?.[1] ?? 0);
+				context.report({
+					node: value ?? providedInProperty,
+					messageId: "disallowedProvidedIn",
+					data: { actual: actual || "this value" }
+				});
+			}
+		};
 	}
 });
 //#endregion
@@ -878,6 +2261,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 +2312,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 +2378,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 +2425,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 +2453,23 @@ 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,
+		"component-resource-filenames": componentResourceFilenames,
 		"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 +2513,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 +2534,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 +2547,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,