@benjavicente/lint-angular 0.0.1

package/README.md

@@ -0,0 +1,29 @@
+# `@benjavicente/lint-angular`
+
+Oxlint/ESLint-compatible plugin for Angular project rules.
+
+## Rules
+
+| Rule                                                                                                  | Default | Fixable |
+| ----------------------------------------------------------------------------------------------------- | ------- | ------- |
+| [`rules-of-inject`](./src/rules/rules-of-inject/)                                                     | ✅      |         |
+| [`avoid-explicit-injection-context`](./src/rules/avoid-explicit-injection-context/)                   | ✅      |         |
+| [`avoid-ng-modules`](./src/rules/avoid-ng-modules/)                                                   | ✅      |         |
+| [`avoid-writing-signals-in-reactive-context`](./src/rules/avoid-writing-signals-in-reactive-context/) | ✅      |         |
+| [`class-member-order`](./src/rules/class-member-order/)                                               | ✅      |         |
+| [`component-class-matches-filename`](./src/rules/component-class-matches-filename/)                   | ✅      |         |
+| [`prefer-private-elements`](./src/rules/prefer-private-elements/)                                     | ✅      | ✅      |
+| [`prefer-load-component-over-load-children`](./src/rules/prefer-load-component-over-load-children/)   | ✅      |         |
+| [`prefer-style-url`](./src/rules/prefer-style-url/)                                                   | ✅      | ✅      |
+| [`restrict-injectable-provided-in`](./src/rules/restrict-injectable-provided-in/)                     | ✅      |         |
+
+## Oxlint setup
+
+```jsonc
+{
+  "jsPlugins": ["@benjavicente/lint-angular"],
+  "rules": {
+    "@benjavicente/lint-angular/rules-of-inject": "error",
+  },
+}
+```

package/dist/index.d.mts

@@ -0,0 +1,6 @@
+import { Plugin } from "@oxlint/plugins";
+
+//#region src/index.d.ts
+declare const plugin: Plugin;
+//#endregion
+export { plugin as default };

package/dist/index.mjs

@@ -0,0 +1,1157 @@
+import { defineRule, eslintCompatPlugin } from "@oxlint/plugins";
+//#region src/utilities/ast.ts
+function getPropertyName(node) {
+	if (!node) return null;
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "PrivateIdentifier") return node.name;
+	if (node.type === "Literal") return String(node.value);
+	if (node.type === "StringLiteral") return String(node.value);
+	return null;
+}
+function getDecoratorName(decoratorNode) {
+	if (!decoratorNode) return null;
+	const expression = decoratorNode.expression ?? decoratorNode;
+	const callee = expression?.type === "CallExpression" ? expression.callee : expression;
+	if (!callee) return null;
+	if (callee.type === "Identifier") return callee.name;
+	if (callee.type === "MemberExpression") return getPropertyName(callee.property);
+	return null;
+}
+function getRange(node) {
+	if (!node) return null;
+	if (Array.isArray(node.range) && typeof node.range[0] === "number") return [node.range[0], node.range[1]];
+	if (typeof node.start === "number" && typeof node.end === "number") return [node.start, node.end];
+	return null;
+}
+//#endregion
+//#region src/rules/class-member-order/index.ts
+const ANGULAR_CLASS_DECORATOR_NAMES$1 = new Set([
+	"Component",
+	"Directive",
+	"Injectable",
+	"Pipe",
+	"NgModule"
+]);
+const INPUT_MODEL_CALL_NAMES = new Set(["input", "model"]);
+const OUTPUT_CALL_NAMES = new Set(["output", "outputFromObservable"]);
+const CLASS_FIELD_TYPES$1 = new Set([
+	"AccessorProperty",
+	"FieldDefinition",
+	"PropertyDefinition"
+]);
+const ORDER_LABELS = [
+	"plain inject fields",
+	"inputs/models",
+	"outputs",
+	"everything else"
+];
+function hasAngularClassDecorator(classNode) {
+	if (!classNode || !Array.isArray(classNode.decorators)) return false;
+	return classNode.decorators.some((decorator) => ANGULAR_CLASS_DECORATOR_NAMES$1.has(getDecoratorName(decorator) ?? ""));
+}
+function getCallName(node) {
+	if (!node || node.type !== "CallExpression") return null;
+	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;
+}
+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 classifyMember(element) {
+	if (CLASS_FIELD_TYPES$1.has(element.type)) {
+		const callName = getCallName(element.value);
+		if (isDirectInjectCall(element.value)) return 0;
+		if (callName && INPUT_MODEL_CALL_NAMES.has(callName)) return 1;
+		if (hasDecorator(element, new Set(["Input"]))) return 1;
+		if (callName && OUTPUT_CALL_NAMES.has(callName)) return 2;
+		if (hasDecorator(element, new Set(["Output"]))) return 2;
+		return 3;
+	}
+	if (element.type === "MethodDefinition") return 3;
+	return 3;
+}
+const classMemberOrder = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Require Angular class members to be ordered as inject fields, inputs/models, outputs, then everything else.",
+			recommended: true
+		},
+		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]
+						}
+					});
+					continue;
+				}
+				highestSeen = group;
+			}
+		} };
+	}
+});
+//#endregion
+//#region src/rules/avoid-explicit-injection-context/index.ts
+const DEFAULT_DISALLOW_INJECT_INJECTOR = true;
+const DEFAULT_DISALLOW_RUN_IN_INJECTION_CONTEXT = true;
+const RUN_IN_INJECTION_CONTEXT_NAMES = new Set(["runInInjectionContext", "runInContext"]);
+function isAngularNamespaceMember(node, namespaces, memberName) {
+	return node?.type === "MemberExpression" && node.object?.type === "Identifier" && namespaces.has(node.object.name) && getPropertyName(node.property) === memberName;
+}
+function isInjectCall(callNode, injectNames, angularNamespaces) {
+	const callee = callNode.callee;
+	return callee?.type === "Identifier" && injectNames.has(callee.name) || isAngularNamespaceMember(callee, angularNamespaces, "inject");
+}
+function isInjectorReference(node, injectorNames, angularNamespaces) {
+	return node?.type === "Identifier" && injectorNames.has(node.name) || isAngularNamespaceMember(node, angularNamespaces, "Injector");
+}
+function isDisallowedInjectInjector(callNode, injectNames, injectorNames, angularNamespaces) {
+	if (!isInjectCall(callNode, injectNames, angularNamespaces)) return false;
+	return isInjectorReference(callNode.arguments?.[0], injectorNames, angularNamespaces);
+}
+function isDisallowedRunInInjectionContext(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) ?? "");
+	return false;
+}
+const avoidExplicitInjectionContext = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Avoid explicit injection-context APIs such as inject(Injector) and runInInjectionContext/runInContext.",
+			recommended: true
+		},
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				disallowInjectInjector: {
+					type: "boolean",
+					default: DEFAULT_DISALLOW_INJECT_INJECTOR
+				},
+				disallowRunInInjectionContext: {
+					type: "boolean",
+					default: DEFAULT_DISALLOW_RUN_IN_INJECTION_CONTEXT
+				}
+			}
+		}],
+		messages: {
+			avoidInjectInjector: "Avoid inject(Injector). Prefer APIs that run in the ambient Angular injection context.",
+			avoidRunInInjectionContext: "Avoid runInInjectionContext/runInContext. Prefer APIs that run in the ambient Angular injection context."
+		}
+	},
+	createOnce(context) {
+		const injectNames = /* @__PURE__ */ new Set();
+		const injectorNames = /* @__PURE__ */ new Set();
+		const runInInjectionContextNames = /* @__PURE__ */ new Set();
+		const runInContextNames = /* @__PURE__ */ new Set();
+		const angularNamespaces = /* @__PURE__ */ new Set();
+		return {
+			before() {
+				injectNames.clear();
+				injectorNames.clear();
+				runInInjectionContextNames.clear();
+				runInContextNames.clear();
+				angularNamespaces.clear();
+			},
+			ImportDeclaration(node) {
+				if (node.source?.value !== "@angular/core") return;
+				for (const specifier of node.specifiers ?? []) {
+					if (specifier.type === "ImportSpecifier") {
+						const importedName = getPropertyName(specifier.imported);
+						if (importedName === "inject") injectNames.add(specifier.local.name);
+						if (importedName === "Injector") injectorNames.add(specifier.local.name);
+						if (importedName === "runInInjectionContext") runInInjectionContextNames.add(specifier.local.name);
+						if (importedName === "runInContext") runInContextNames.add(specifier.local.name);
+					}
+					if (specifier.type === "ImportNamespaceSpecifier") angularNamespaces.add(specifier.local.name);
+				}
+			},
+			CallExpression(node) {
+				const callNode = node;
+				const options = context.options[0] ?? {};
+				const disallowInjectInjector = options.disallowInjectInjector ?? DEFAULT_DISALLOW_INJECT_INJECTOR;
+				const disallowRunInInjectionContext = options.disallowRunInInjectionContext ?? DEFAULT_DISALLOW_RUN_IN_INJECTION_CONTEXT;
+				if (disallowInjectInjector && isDisallowedInjectInjector(callNode, injectNames, injectorNames, angularNamespaces)) context.report({
+					node: callNode.callee,
+					messageId: "avoidInjectInjector"
+				});
+				if (disallowRunInInjectionContext && isDisallowedRunInInjectionContext(callNode, runInInjectionContextNames, runInContextNames, angularNamespaces)) context.report({
+					node: callNode.callee,
+					messageId: "avoidRunInInjectionContext"
+				});
+			}
+		};
+	}
+});
+//#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;
+	const expression = node.expression;
+	if (expression?.type !== "CallExpression") return null;
+	const metadata = expression.arguments?.[0];
+	return metadata?.type === "ObjectExpression" ? metadata : null;
+}
+function getArrayElementsFromProperty(metadata, propertyName) {
+	const property = (metadata.properties ?? []).find((candidate) => candidate.type === "Property" && !candidate.computed && getPropertyName(candidate.key) === propertyName && candidate.value?.type === "ArrayExpression");
+	if (!property) return [];
+	return property.value.elements?.filter(Boolean) ?? [];
+}
+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 getNgModuleClassNode(decoratorNode) {
+	const parent = decoratorNode.parent;
+	if (parent?.type === "ClassDeclaration" || parent?.type === "ClassExpression") return parent;
+	return null;
+}
+function getStaticForRootMethod(classNode) {
+	if (!classNode?.body?.body) return null;
+	return classNode.body.body.find((element) => element.type === "MethodDefinition" && !!element.static && getPropertyName(element.key) === "forRoot") ?? null;
+}
+const avoidNgModules = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Avoid NgModules in favor of standalone APIs and provider functions in modern Angular.",
+			recommended: true
+		},
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				allowForGrouping: {
+					type: "boolean",
+					default: DEFAULT_ALLOW_FOR_GROUPING
+				},
+				allowForProviding: {
+					type: "boolean",
+					default: DEFAULT_ALLOW_FOR_PROVIDING
+				},
+				allowForRouting: {
+					type: "boolean",
+					default: DEFAULT_ALLOW_FOR_ROUTING
+				}
+			}
+		}],
+		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')."
+		}
+	},
+	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;
+					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 (!isRouterModuleForChild(call)) continue;
+				context.report({
+					node: call,
+					messageId: "avoidRouterForChild"
+				});
+			}
+		} };
+	}
+});
+//#endregion
+//#region src/rules/avoid-writing-signals-in-reactive-context/index.ts
+const SIGNAL_WRITE_METHODS = new Set([
+	"set",
+	"update",
+	"mutate"
+]);
+const KNOWN_SIGNAL_CREATION_FUNCTIONS = new Set([
+	"signal",
+	"model",
+	"linkedSignal"
+]);
+const LINKED_SIGNAL_CREATOR_NAME = "linkedSignal";
+const COMPUTED_CREATOR_NAME = "computed";
+const EFFECT_CREATOR_NAME = "effect";
+function isAngularCoreNamespaceMember(node, angularNamespaces, memberName) {
+	return node?.type === "MemberExpression" && node.object?.type === "Identifier" && angularNamespaces.has(node.object.name) && getPropertyName(node.property) === memberName;
+}
+function isSignalCreatorCall(node, signalCreatorNames, angularNamespaces) {
+	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));
+}
+function isEffectCall(node, effectNames, angularNamespaces) {
+	const callee = node.callee;
+	return callee?.type === "Identifier" && effectNames.has(callee.name) || isAngularCoreNamespaceMember(callee, angularNamespaces, "effect");
+}
+function isReactiveCreatorCall(node, creatorNames, angularNamespaces, angularMemberName) {
+	const callee = node.callee;
+	return callee?.type === "Identifier" && creatorNames.has(callee.name) || isAngularCoreNamespaceMember(callee, angularNamespaces, angularMemberName);
+}
+function isKnownSignalObject(objectNode, signalVariables, classSignalProperties) {
+	if (!objectNode) return false;
+	if (objectNode.type === "Identifier") return signalVariables.has(objectNode.name);
+	return objectNode.type === "MemberExpression" && objectNode.object?.type === "ThisExpression" && objectNode.property?.type === "Identifier" && classSignalProperties.has(objectNode.property.name);
+}
+function visitNodes$1(node, visitor) {
+	if (!node) return;
+	if (Array.isArray(node)) {
+		for (const item of node) visitNodes$1(item, visitor);
+		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);
+	}
+}
+const avoidWritingSignalsInReactiveContext = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Avoid writing to signals inside reactive callbacks such as effect(), computed(), and linkedSignal().",
+			recommended: true
+		},
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				allowEffects: {
+					type: "boolean",
+					default: false
+				},
+				allowComputedAndLinkedSignals: {
+					type: "boolean",
+					default: false
+				}
+			}
+		}],
+		messages: { avoidSignalWriteInReactiveContext: "Avoid setting signal values inside {{contextName}}; move writes outside reactive derivations and effects." }
+	},
+	createOnce(context) {
+		const effectNames = /* @__PURE__ */ new Set();
+		const computedNames = /* @__PURE__ */ new Set();
+		const linkedSignalNames = /* @__PURE__ */ new Set();
+		const signalCreatorNames = /* @__PURE__ */ new Set();
+		const angularNamespaces = /* @__PURE__ */ new Set();
+		const signalVariables = /* @__PURE__ */ new Set();
+		const classSignalProperties = /* @__PURE__ */ new Set();
+		return {
+			before() {
+				effectNames.clear();
+				computedNames.clear();
+				linkedSignalNames.clear();
+				signalCreatorNames.clear();
+				angularNamespaces.clear();
+				signalVariables.clear();
+				classSignalProperties.clear();
+			},
+			ImportDeclaration(node) {
+				if (node.source?.value !== "@angular/core") return;
+				for (const specifier of node.specifiers ?? []) {
+					if (specifier.type === "ImportSpecifier") {
+						const importedName = getPropertyName(specifier.imported);
+						if (importedName === EFFECT_CREATOR_NAME) effectNames.add(specifier.local.name);
+						if (importedName === COMPUTED_CREATOR_NAME) computedNames.add(specifier.local.name);
+						if (importedName === LINKED_SIGNAL_CREATOR_NAME) linkedSignalNames.add(specifier.local.name);
+						if (importedName && KNOWN_SIGNAL_CREATION_FUNCTIONS.has(importedName)) signalCreatorNames.add(specifier.local.name);
+					}
+					if (specifier.type === "ImportNamespaceSpecifier") angularNamespaces.add(specifier.local.name);
+				}
+			},
+			VariableDeclarator(node) {
+				const declarator = node;
+				if (declarator.id?.type !== "Identifier") return;
+				if (!isSignalCreatorCall(declarator.init, signalCreatorNames, angularNamespaces)) return;
+				signalVariables.add(declarator.id.name);
+			},
+			"PropertyDefinition, FieldDefinition, AccessorProperty"(node) {
+				const property = node;
+				if (property.key?.type !== "Identifier") return;
+				if (!isSignalCreatorCall(property.value, signalCreatorNames, angularNamespaces)) return;
+				classSignalProperties.add(property.key.name);
+			},
+			CallExpression(node) {
+				const options = context.options?.[0] ?? {};
+				const allowEffects = options.allowEffects ?? false;
+				const allowComputedAndLinkedSignals = options.allowComputedAndLinkedSignals ?? false;
+				const callNode = node;
+				const callbackCandidates = [];
+				if (!allowEffects && isEffectCall(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)) {
+					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 ?? []) {
+					const argument = argumentNode;
+					if (argument.type === "ArrowFunctionExpression" || argument.type === "FunctionExpression") {
+						callbackCandidates.push({
+							callback: argument,
+							contextName: "linkedSignal()"
+						});
+						continue;
+					}
+					if (argument.type !== "ObjectExpression") continue;
+					for (const propertyNode of argument.properties ?? []) {
+						const property = propertyNode;
+						if (property.type !== "Property" || property.computed) continue;
+						if (getPropertyName(property.key) !== "computation") continue;
+						if (property.value?.type !== "ArrowFunctionExpression" && property.value?.type !== "FunctionExpression") continue;
+						callbackCandidates.push({
+							callback: property.value,
+							contextName: "linkedSignal().computation"
+						});
+					}
+				}
+				for (const { callback, contextName } of callbackCandidates) visitNodes$1(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;
+					context.report({
+						node: callee.property ?? callee,
+						messageId: "avoidSignalWriteInReactiveContext",
+						data: { contextName }
+					});
+				});
+			},
+			"Program:exit"() {
+				effectNames.clear();
+				computedNames.clear();
+				linkedSignalNames.clear();
+				signalCreatorNames.clear();
+				angularNamespaces.clear();
+				signalVariables.clear();
+				classSignalProperties.clear();
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/component-class-matches-filename/index.ts
+function toPascalCase(raw) {
+	return raw.split(/[-_\s.]+/u).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function getExpectedComponentClassName(filename) {
+	const base = filename.split(/[/\\]/u).at(-1) ?? "";
+	const match = /^(.*)\.component\.ts$/u.exec(base);
+	if (!match) return null;
+	const stem = match[1];
+	const pascal = toPascalCase(stem);
+	return pascal ? `${pascal}Component` : null;
+}
+const componentClassMatchesFilename = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Require the component class name to match its *.component.ts filename.",
+			recommended: true
+		},
+		schema: [],
+		messages: { classNameMismatch: "Component class name should be '{{expectedName}}' to match the filename '{{filename}}'." }
+	},
+	createOnce(context) {
+		const classDeclarations = [];
+		return {
+			before() {
+				classDeclarations.length = 0;
+			},
+			ClassDeclaration(node) {
+				classDeclarations.push(node);
+			},
+			after() {
+				const filename = context.filename ?? "";
+				const expectedName = getExpectedComponentClassName(filename);
+				if (!expectedName) return;
+				const baseFilename = filename.split(/[/\\]/u).at(-1) ?? filename;
+				const classNode = classDeclarations.find((candidate) => candidate.parent?.type === "ExportNamedDeclaration" || candidate.parent?.type === "ExportDefaultDeclaration") ?? null ?? classDeclarations[0];
+				if (!classNode?.id?.name) return;
+				if (classNode.id.name === expectedName) return;
+				context.report({
+					node: classNode.id,
+					messageId: "classNameMismatch",
+					data: {
+						expectedName,
+						filename: baseFilename
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/prefer-load-component-over-load-children/index.ts
+function isRoutesTypeAnnotation(node) {
+	const typeAnnotation = node?.typeAnnotation;
+	if (!typeAnnotation || typeAnnotation.type !== "TSTypeAnnotation") return false;
+	const annotation = typeAnnotation.typeAnnotation;
+	if (!annotation || annotation.type !== "TSTypeReference") return false;
+	return getPropertyName(annotation.typeName) === "Routes";
+}
+function isExportedConstDeclarator(node) {
+	if (node.type !== "VariableDeclarator") return false;
+	const declaration = node.parent;
+	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",
+		docs: {
+			description: "Prefer lazy loading route components with loadComponent and disallow loadChildren in exported Routes arrays.",
+			recommended: true
+		},
+		schema: [],
+		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"
+				});
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/prefer-private-elements/index.ts
+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 (element.type === "MethodDefinition" && element.kind === "constructor") return null;
+	const name = getPropertyName(element.key);
+	if (!name || element.key?.type !== "Identifier") return null;
+	return {
+		element,
+		nameNode: element.key,
+		name,
+		isStatic: !!element.static,
+		accessorKind: element.type === "MethodDefinition" && (element.kind === "get" || element.kind === "set") ? element.kind : null
+	};
+}
+function getPrivateModifierRange(context, element, nameNode) {
+	const elementRange = getRange(element);
+	const nameRange = getRange(nameNode);
+	if (!elementRange || !nameRange) return null;
+	const text = context.sourceCode.text.slice(elementRange[0], nameRange[0]);
+	const match = /\bprivate\b\s*/u.exec(text);
+	return match ? [elementRange[0] + match.index, elementRange[0] + match.index + match[0].length] : null;
+}
+function sameStaticName(target, candidate) {
+	return !!candidate.static === target.isStatic && getPropertyName(candidate.key) === target.name;
+}
+function collectDeclarationEdits(context, classNode, target) {
+	const privateRange = getPrivateModifierRange(context, target.element, target.nameNode);
+	const nameRange = getRange(target.nameNode);
+	if (!privateRange || !nameRange) return null;
+	const declarations = [{
+		privateRange,
+		nameRange,
+		name: target.name
+	}];
+	for (const element of classNode.body?.body ?? []) {
+		if (element === target.element || !sameStaticName(target, element)) continue;
+		const other = getPrivateTarget(element);
+		if (!(target.accessorKind && other?.accessorKind && target.accessorKind !== other.accessorKind)) return null;
+		const otherPrivateRange = getPrivateModifierRange(context, other.element, other.nameNode);
+		const otherNameRange = getRange(other.nameNode);
+		if (!otherPrivateRange || !otherNameRange) return null;
+		declarations.push({
+			privateRange: otherPrivateRange,
+			nameRange: otherNameRange,
+			name: other.name
+		});
+	}
+	return declarations;
+}
+function isThisOrClassReceiver(node, target, className) {
+	if (!node) return false;
+	if (target.isStatic) return node.type === "Identifier" && !!className && node.name === className;
+	return node.type === "ThisExpression";
+}
+function collectReferenceEdits(classNode, target, className) {
+	const references = [];
+	let unsupported = false;
+	function visit(node, functionDepth) {
+		if (!node || unsupported) return;
+		if (Array.isArray(node)) {
+			for (const item of node) visit(item, functionDepth);
+			return;
+		}
+		if (node !== classNode && (node.type === "ClassDeclaration" || node.type === "ClassExpression")) return;
+		const nextFunctionDepth = node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" ? functionDepth + 1 : functionDepth;
+		if (node.type === "MemberExpression" && !node.computed && getPropertyName(node.property) === target.name) {
+			if (nextFunctionDepth > 1 || !isThisOrClassReceiver(node.object, target, className)) {
+				unsupported = true;
+				return;
+			}
+			const range = getRange(node.property);
+			if (!range) {
+				unsupported = true;
+				return;
+			}
+			references.push({
+				range,
+				name: target.name
+			});
+		}
+		if (node.type === "MemberExpression" && node.computed && getPropertyName(node.property) === target.name) {
+			unsupported = true;
+			return;
+		}
+		for (const [key, value] of Object.entries(node)) {
+			if (key === "parent") continue;
+			if (!value || typeof value !== "object") continue;
+			visit(value, nextFunctionDepth);
+		}
+	}
+	visit(classNode, 0);
+	return unsupported ? null : references;
+}
+function buildFixPlan(context, classNode, target) {
+	const declarations = collectDeclarationEdits(context, classNode, target);
+	if (!declarations) return null;
+	const references = collectReferenceEdits(classNode, target, classNode.id?.type === "Identifier" ? classNode.id.name : null);
+	if (!references) return null;
+	return {
+		declarations,
+		references
+	};
+}
+function getEnclosingClass(context, node) {
+	const ancestors = context.sourceCode.getAncestors(node);
+	for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+		const ancestor = ancestors[index];
+		if (ancestor?.type === "ClassDeclaration" || ancestor?.type === "ClassExpression") return ancestor;
+	}
+	return null;
+}
+function shouldSkipDuplicateAccessorReport(classNode, target) {
+	if (!target.accessorKind) return false;
+	return (classNode.body?.body ?? []).some((element) => {
+		const other = getPrivateTarget(element);
+		return other && other !== target && other.name === target.name && other.isStatic === target.isStatic && other.accessorKind && other.accessorKind !== target.accessorKind && (getRange(other.element)?.[0] ?? Number.POSITIVE_INFINITY) < (getRange(target.element)?.[0] ?? 0);
+	});
+}
+function applyFixPlan(fixer, plan) {
+	const fixes = [];
+	for (const declaration of plan.declarations) {
+		fixes.push(fixer.removeRange(declaration.privateRange));
+		fixes.push(fixer.replaceTextRange(declaration.nameRange, `#${declaration.name}`));
+	}
+	for (const reference of plan.references) fixes.push(fixer.replaceTextRange(reference.range, `#${reference.name}`));
+	return fixes;
+}
+const preferPrivateElements = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Prefer ECMAScript private elements over TypeScript private members.",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { preferPrivateElements: "TypeScript private member {{name}} should be an ECMAScript private element." }
+	},
+	createOnce(context) {
+		return { "PropertyDefinition, FieldDefinition, AccessorProperty, MethodDefinition"(node) {
+			const target = getPrivateTarget(node);
+			if (!target) return;
+			const classNode = getEnclosingClass(context, node);
+			if (!classNode || shouldSkipDuplicateAccessorReport(classNode, target)) return;
+			const fixPlan = buildFixPlan(context, classNode, target);
+			context.report({
+				node: target.nameNode,
+				messageId: "preferPrivateElements",
+				data: { name: target.name },
+				fix: fixPlan ? (fixer) => applyFixPlan(fixer, fixPlan) : void 0
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/prefer-style-url/index.ts
+function isComponentDecoratorCall(node) {
+	const callee = node.callee;
+	if (callee?.type === "Identifier") return callee.name === "Component";
+	return callee?.type === "MemberExpression" && getPropertyName(callee.property) === "Component";
+}
+function isSingleStyleFileNode(node) {
+	if (!node) return false;
+	if (node.type === "Literal" || node.type === "StringLiteral") return typeof node.value === "string";
+	return node.type === "TemplateLiteral" && node.expressions?.length === 0;
+}
+const preferStyleUrl = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Prefer Angular component styleUrl when there is only one style file.",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		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
+				});
+			}
+		} };
+	}
+});
+//#endregion
+//#region src/rules/restrict-injectable-provided-in/index.ts
+const ALLOWED_PROVIDED_IN_VALUES = new Set(["root", "platform"]);
+function getInjectableMetadata(node) {
+	if (node.type !== "Decorator") return null;
+	if (getDecoratorName(node) !== "Injectable") return null;
+	const expression = node.expression;
+	if (expression?.type !== "CallExpression") return null;
+	const metadata = expression.arguments?.[0];
+	return metadata?.type === "ObjectExpression" ? metadata : null;
+}
+function getProvidedInProperty(metadata) {
+	return (metadata.properties ?? []).find((candidate) => candidate.type === "Property" && !candidate.computed && getPropertyName(candidate.key) === "providedIn") ?? null;
+}
+function isAllowedProvidedInValue(node) {
+	if (!node) return false;
+	if (node.type === "Literal" || node.type === "StringLiteral") return typeof node.value === "string" && ALLOWED_PROVIDED_IN_VALUES.has(node.value);
+	return false;
+}
+const restrictInjectableProvidedIn = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Require @Injectable providedIn to be only 'root' or 'platform'.",
+			recommended: true
+		},
+		schema: [],
+		messages: { disallowedProvidedIn: "@Injectable providedIn should be '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" }
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/rules-of-inject/index.ts
+const DEFAULT_ALLOWED_FUNCTION_NAMES = [];
+const DEFAULT_INJECT_FUNCTION_PREFIXES = ["injext"];
+const DEFAULT_INJECT_FUNCTION_SUFFIXES = ["Guard"];
+const DEFAULT_RUNS_IN_INJECTION_CONTEXT = [];
+const ROUTER_CONTEXT_PROPERTY_NAMES = new Set([
+	"loadChildren",
+	"loadComponent",
+	"canActivate",
+	"canActivateChild",
+	"canDeactivate",
+	"canMatch",
+	"canLoad",
+	"redirectTo",
+	"resolve",
+	"title"
+]);
+const ANGULAR_CLASS_DECORATOR_NAMES = new Set([
+	"Component",
+	"Directive",
+	"Injectable",
+	"Service",
+	"Pipe",
+	"NgModule"
+]);
+const INJECTION_CONTEXT_RUNNER_NAMES = new Set(["runInInjectionContext", "runInContext"]);
+const INJECTION_CONTEXT_FUNCTION_TYPE_NAMES = new Set([
+	"CanActivateFn",
+	"CanActivateChildFn",
+	"CanDeactivateFn",
+	"CanLoadFn",
+	"CanMatchFn",
+	"HttpInterceptorFn",
+	"RedirectFunction",
+	"ResolveFn"
+]);
+const FUNCTION_TYPES = new Set([
+	"ArrowFunctionExpression",
+	"FunctionDeclaration",
+	"FunctionExpression"
+]);
+const CLASS_FIELD_TYPES = new Set([
+	"AccessorProperty",
+	"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);
+}
+function getAncestors(context, node) {
+	return context.sourceCode.getAncestors(node);
+}
+function isPropertyValueFunction(functionNode, propertyNames) {
+	const parent = functionNode.parent;
+	return parent?.type === "Property" && parent.value === functionNode && propertyNames.has(getPropertyName(parent.key) ?? "");
+}
+function isRunInInjectionContextCallback(functionNode) {
+	const parent = functionNode.parent;
+	if (parent?.type !== "CallExpression") return false;
+	if (!parent.arguments?.includes(functionNode)) return false;
+	const callee = parent.callee;
+	if (callee?.type === "Identifier") return INJECTION_CONTEXT_RUNNER_NAMES.has(callee.name);
+	return callee?.type === "MemberExpression" && INJECTION_CONTEXT_RUNNER_NAMES.has(getPropertyName(callee.property) ?? "");
+}
+function isNestedInPropertyValue(functionNode, propertyNames) {
+	let current = functionNode.parent;
+	while (current) {
+		if (current.type === "Property" && propertyNames.has(getPropertyName(current.key) ?? "")) return true;
+		if (isFunction(current)) return false;
+		current = current.parent;
+	}
+	return false;
+}
+function getFunctionName(functionNode) {
+	const parent = skipTransparentExpressionParents(functionNode.parent);
+	if (functionNode.type === "FunctionDeclaration") return functionNode.id?.name ?? null;
+	if (parent?.type === "VariableDeclarator" && parent.id?.type === "Identifier") return parent.id.name;
+	if (parent?.type === "Property" && parent.value === functionNode) return getPropertyName(parent.key);
+	if (parent?.type === "MethodDefinition" && parent.value === functionNode) return getPropertyName(parent.key);
+	return null;
+}
+function skipTransparentExpressionParents(node) {
+	let current = node;
+	while (current?.type === "ParenthesizedExpression" || current?.type === "TSAsExpression" || current?.type === "TSSatisfiesExpression" || current?.type === "TSNonNullExpression") current = current.parent;
+	return current ?? null;
+}
+function getTransparentExpressionTypeName(functionNode) {
+	let current = functionNode.parent;
+	while (current?.type === "ParenthesizedExpression" || current?.type === "TSAsExpression" || current?.type === "TSSatisfiesExpression" || current?.type === "TSNonNullExpression") {
+		if (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression") {
+			const typeName = getTypeName(current.typeAnnotation);
+			if (typeName) return typeName;
+		}
+		current = current.parent;
+	}
+	return null;
+}
+function getFunctionContextTypeName(functionNode) {
+	const transparentTypeName = getTransparentExpressionTypeName(functionNode);
+	if (transparentTypeName) return transparentTypeName;
+	const parent = skipTransparentExpressionParents(functionNode.parent);
+	if (parent?.type === "VariableDeclarator" && parent.id?.type === "Identifier") return getTypeName(parent.id.typeAnnotation?.typeAnnotation);
+	if (parent?.type === "Property" && parent.value === functionNode) return getTypeName(parent.typeAnnotation?.typeAnnotation);
+	if (parent && CLASS_FIELD_TYPES.has(parent.type) && parent.value === functionNode) return getTypeName(parent.typeAnnotation?.typeAnnotation);
+	return null;
+}
+function isTypedInjectionContextFunction(functionNode) {
+	const typeName = getFunctionContextTypeName(functionNode);
+	if (!typeName) return false;
+	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;
+	const targetStart = nodeStart;
+	function visit(current) {
+		if (!current) return false;
+		if (Array.isArray(current)) return current.some(visit);
+		if (current !== functionNode && isFunction(current)) return false;
+		if (current.type === "AwaitExpression") {
+			const awaitStart = getNodeStart(current);
+			return awaitStart !== null && awaitStart < targetStart;
+		}
+		for (const [key, value] of Object.entries(current)) {
+			if (key === "parent") continue;
+			if (!value || typeof value !== "object") continue;
+			if (visit(value)) return true;
+		}
+		return false;
+	}
+	return visit(functionNode.body);
+}
+function isConstructorFunction(functionNode) {
+	return functionNode.parent?.type === "MethodDefinition" && functionNode.parent.kind === "constructor" && functionNode.parent.value === functionNode;
+}
+function isDirectClassFieldInitializer(ancestors, nearestFunction) {
+	return !!ancestors.findLast((ancestor) => CLASS_FIELD_TYPES.has(ancestor.type)) && !nearestFunction;
+}
+function hasSupportedAngularClassDecorator(classNode) {
+	if (!classNode) return false;
+	if (!Array.isArray(classNode.decorators)) return false;
+	return classNode.decorators.some((decorator) => ANGULAR_CLASS_DECORATOR_NAMES.has(getDecoratorName(decorator) ?? ""));
+}
+function isAllowedInjectionContext(context, node, allowedFunctionNames, injectFunctionPrefixes, injectFunctionSuffixes) {
+	const ancestors = getAncestors(context, node);
+	const nearestFunction = ancestors.findLast(isFunction);
+	const enclosingClass = ancestors.findLast((ancestor) => ancestor.type === "ClassDeclaration" || ancestor.type === "ClassExpression");
+	if (nearestFunction && hasAwaitBeforeNodeInFunction(nearestFunction, node)) return false;
+	if (isDirectClassFieldInitializer(ancestors, nearestFunction) && hasSupportedAngularClassDecorator(enclosingClass)) return true;
+	if (!nearestFunction) return false;
+	if (isConstructorFunction(nearestFunction) && hasSupportedAngularClassDecorator(enclosingClass)) return true;
+	if (isPropertyValueFunction(nearestFunction, new Set(["useFactory", "factory"]))) return true;
+	if (isRunInInjectionContextCallback(nearestFunction)) return true;
+	if (isTypedInjectionContextFunction(nearestFunction)) return true;
+	if (isNestedInPropertyValue(nearestFunction, ROUTER_CONTEXT_PROPERTY_NAMES)) return true;
+	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) {
+	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";
+}
+function isInjectLikeHelperCall(node, injectNames, injectFunctionPrefixes, injectFunctionSuffixes, runsInInjectionContextFunctionNames) {
+	const callee = node.callee;
+	if (callee?.type !== "Identifier") 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)));
+}
+//#endregion
+//#region src/index.ts
+const plugin = eslintCompatPlugin({
+	meta: { name: "@benjavicente/lint-angular" },
+	rules: {
+		"avoid-explicit-injection-context": avoidExplicitInjectionContext,
+		"avoid-ng-modules": avoidNgModules,
+		"avoid-writing-signals-in-reactive-context": avoidWritingSignalsInReactiveContext,
+		"class-member-order": classMemberOrder,
+		"component-class-matches-filename": componentClassMatchesFilename,
+		"prefer-load-component-over-load-children": preferLoadComponentOverLoadChildren,
+		"prefer-private-elements": preferPrivateElements,
+		"prefer-style-url": preferStyleUrl,
+		"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.",
+					recommended: true
+				},
+				schema: [{
+					type: "object",
+					additionalProperties: false,
+					properties: {
+						allowedFunctionNames: {
+							type: "array",
+							items: { type: "string" },
+							default: DEFAULT_ALLOWED_FUNCTION_NAMES
+						},
+						checkUnimportedInject: {
+							type: "boolean",
+							default: false
+						},
+						injectFunctionPrefixes: {
+							type: "array",
+							items: { type: "string" },
+							default: DEFAULT_INJECT_FUNCTION_PREFIXES
+						},
+						injectFunctionSuffixes: {
+							type: "array",
+							items: { type: "string" },
+							default: DEFAULT_INJECT_FUNCTION_SUFFIXES
+						},
+						runsInInjectionContext: {
+							type: "array",
+							items: {
+								type: "object",
+								additionalProperties: false,
+								required: ["from", "imports"],
+								properties: {
+									from: { type: "string" },
+									imports: { anyOf: [{ const: "all" }, {
+										type: "array",
+										items: { type: "string" }
+									}] }
+								}
+							},
+							default: DEFAULT_RUNS_IN_INJECTION_CONTEXT
+						}
+					}
+				}],
+				messages: { disallowedInject: "Angular 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." }
+			},
+			createOnce(context) {
+				const injectNames = /* @__PURE__ */ new Set();
+				const angularNamespaces = /* @__PURE__ */ new Set();
+				const runsInInjectionContextFunctionNames = /* @__PURE__ */ new Set();
+				let runsInInjectionContextRules = [];
+				return {
+					before() {
+						injectNames.clear();
+						angularNamespaces.clear();
+						runsInInjectionContextFunctionNames.clear();
+						runsInInjectionContextRules = (context.options[0] ?? {}).runsInInjectionContext ?? DEFAULT_RUNS_IN_INJECTION_CONTEXT;
+					},
+					ImportDeclaration(node) {
+						const source = node.source?.value;
+						const matchingRule = typeof source === "string" ? runsInInjectionContextRules.find((rule) => rule.from === source) : null;
+						if (matchingRule) for (const specifier of node.specifiers ?? []) {
+							if (specifier.type === "ImportSpecifier" && (matchingRule.imports === "all" || matchingRule.imports.includes(getPropertyName(specifier.imported) ?? ""))) runsInInjectionContextFunctionNames.add(specifier.local.name);
+							if ((specifier.type === "ImportDefaultSpecifier" || specifier.type === "ImportNamespaceSpecifier") && matchingRule.imports === "all") runsInInjectionContextFunctionNames.add(specifier.local.name);
+						}
+						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);
+						}
+					},
+					CallExpression(node) {
+						const options = context.options[0] ?? {};
+						const allowedFunctionNames = new Set(options.allowedFunctionNames ?? DEFAULT_ALLOWED_FUNCTION_NAMES);
+						const checkUnimportedInject = options.checkUnimportedInject ?? false;
+						const injectFunctionPrefixes = options.injectFunctionPrefixes ?? DEFAULT_INJECT_FUNCTION_PREFIXES;
+						const injectFunctionSuffixes = options.injectFunctionSuffixes ?? DEFAULT_INJECT_FUNCTION_SUFFIXES;
+						const inAllowedContext = isAllowedInjectionContext(context, node, allowedFunctionNames, injectFunctionPrefixes, injectFunctionSuffixes);
+						if (isInjectLikeHelperCall(node, injectNames, injectFunctionPrefixes, injectFunctionSuffixes, runsInInjectionContextFunctionNames) && !inAllowedContext) {
+							context.report({
+								node: node.callee,
+								messageId: "disallowedInject"
+							});
+							return;
+						}
+						if (!isAngularInjectCall(node, injectNames, angularNamespaces, checkUnimportedInject)) return;
+						if (inAllowedContext) return;
+						context.report({
+							node: node.callee,
+							messageId: "disallowedInject"
+						});
+					}
+				};
+			}
+		})
+	}
+});
+//#endregion
+export { plugin as default };

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@benjavicente/lint-angular",
+  "version": "0.0.1",
+  "description": "Oxlint/ESLint-compatible rules for Angular.",
+  "keywords": [
+    "angular",
+    "eslint",
+    "oxlint"
+  ],
+  "license": "MIT",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "fmt": "vp fmt src",
+    "lint": "vp lint src",
+    "test": "vp test run"
+  },
+  "dependencies": {
+    "@oxlint/plugins": "^1.61.0"
+  },
+  "devDependencies": {
+    "@types/estree": "^1.0.8",
+    "oxlint-vitest-rule-tester": "workspace:*",
+    "typescript": "^6.0.3",
+    "vite-plus": "catalog:",
+    "vitest": "catalog:"
+  }
+}