@angular-eslint/eslint-plugin 22.0.1-alpha.16 → 22.0.1-alpha.18

package/README.md

@@ -23,6 +23,7 @@ The premade flat configs that combine these rules are provided by the umbrella [
 | --- | --- | --- | --- | --- |
 | [`computed-must-return`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/computed-must-return.md) | Ensures that computed() returns a value. Omitting the value is likely a mistake. |  |  |  |
 | [`contextual-lifecycle`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/contextual-lifecycle.md) | Ensures that lifecycle methods are used in a correct context | :white_check_mark: |  |  |
+| [`inject-at-top`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/inject-at-top.md) | Requires inject() calls to be declared at the top of the class, before any other member |  |  |  |
 | [`no-async-lifecycle-method`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-async-lifecycle-method.md) | Angular Lifecycle methods should not be async. Angular does not wait for async lifecycle but the code incorrectly suggests it does. |  |  |  |
 | [`no-attribute-decorator`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-attribute-decorator.md) | The @Attribute decorator is used to obtain a single value for an attribute. This is a much less common use case than getting a stream of values (using @Input), so the @Attribute decorator is often mistakenly used when @Input is intended. This rule disallows the usage of @Attribute decorator entirely to prevent these mistakes. |  |  |  |
 | [`no-developer-preview`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-developer-preview.md) | Disallow using code which is marked as developer preview |  |  |  |

package/dist/index.d.ts

@@ -27,6 +27,9 @@ declare const _default: {
         "directive-selector": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/directive-selector").MessageIds, import("./rules/directive-selector").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        "inject-at-top": import("@typescript-eslint/utils/ts-eslint").RuleModule<"injectAtTop", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         "no-async-lifecycle-method": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noAsyncLifecycleMethod", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoJA,kBAqDE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuJA,kBAsDE"}

package/dist/index.js

@@ -81,6 +81,7 @@ const no_experimental_1 = __importStar(require("./rules/no-experimental"));
 const no_developer_preview_1 = __importStar(require("./rules/no-developer-preview"));
 const no_implicit_take_until_destroyed_1 = __importStar(require("./rules/no-implicit-take-until-destroyed"));
 const computed_must_return_1 = __importStar(require("./rules/computed-must-return"));
+const inject_at_top_1 = __importStar(require("./rules/inject-at-top"));
 module.exports = {
     rules: {
         [component_class_suffix_1.RULE_NAME]: component_class_suffix_1.default,
@@ -92,6 +93,7 @@ module.exports = {
         [contextual_lifecycle_1.RULE_NAME]: contextual_lifecycle_1.default,
         [directive_class_suffix_1.RULE_NAME]: directive_class_suffix_1.default,
         [directive_selector_1.RULE_NAME]: directive_selector_1.default,
+        [inject_at_top_1.RULE_NAME]: inject_at_top_1.default,
         [no_async_lifecycle_method_1.RULE_NAME]: no_async_lifecycle_method_1.default,
         [no_attribute_decorator_1.RULE_NAME]: no_attribute_decorator_1.default,
         [no_developer_preview_1.RULE_NAME]: no_developer_preview_1.default,

package/dist/rules/inject-at-top.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'injectAtTop';
+export declare const RULE_NAME = "inject-at-top";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"injectAtTop", [], import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=inject-at-top.d.ts.map

package/dist/rules/inject-at-top.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-at-top.d.ts","sourceRoot":"","sources":["../../src/rules/inject-at-top.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AAEzB,MAAM,MAAM,UAAU,GAAG,aAAa,CAAC;AACvC,eAAO,MAAM,SAAS,kBAAkB,CAAC;;;;AAEzC,wBAyFG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/inject-at-top.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const utils_1 = require("@angular-eslint/utils");
+const utils_2 = require("@typescript-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'inject-at-top';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Requires inject() calls to be declared at the top of the class, before any other member',
+        },
+        schema: [],
+        messages: {
+            injectAtTop: 'Move this inject() to the top of the class. Class fields are initialized in the order they are written, so anything declared above this line cannot safely use the service yet.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const angularDecoratorsPattern = (0, utils_1.toPattern)([
+            'Component',
+            'Directive',
+            'Injectable',
+            'Pipe',
+            'Service',
+        ]);
+        function hasEagerInject(node) {
+            if (!node) {
+                return false;
+            }
+            if (node.type === utils_2.AST_NODE_TYPES.CallExpression &&
+                node.callee.type === utils_2.AST_NODE_TYPES.Identifier &&
+                node.callee.name === 'inject') {
+                return true;
+            }
+            const isFn = node.type === utils_2.AST_NODE_TYPES.ArrowFunctionExpression ||
+                node.type === utils_2.AST_NODE_TYPES.FunctionExpression;
+            const isIIFE = isFn &&
+                node.parent?.type === utils_2.AST_NODE_TYPES.CallExpression &&
+                node.parent.callee === node;
+            if (node.type === utils_2.AST_NODE_TYPES.ClassExpression || (isFn && !isIIFE)) {
+                return false;
+            }
+            return Object.values(node)
+                .flat()
+                .some((child) => child &&
+                typeof child === 'object' &&
+                'type' in child &&
+                child !== node.parent &&
+                hasEagerInject(child));
+        }
+        return {
+            [`${utils_1.Selectors.decoratorDefinition(angularDecoratorsPattern)} > ClassBody`](node) {
+                let seenNonInject = false;
+                for (const member of node.body) {
+                    if ('static' in member && member.static) {
+                        continue;
+                    }
+                    if (member.type === utils_2.AST_NODE_TYPES.PropertyDefinition &&
+                        hasEagerInject(member.value)) {
+                        if (seenNonInject) {
+                            context.report({ node: member, messageId: 'injectAtTop' });
+                        }
+                        continue;
+                    }
+                    seenNonInject = true;
+                }
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Class fields are initialized in the order they are declared, so a field that calls inject() only creates its value when the initializer runs. Anything declared above that line which tries to read the injected service will see undefined, and the error message (usually something like 'Cannot read properties of undefined') points at the consumer, not at the field that was initialized out of order. TypeScript catches the obvious shape of this bug when a later-declared field is referenced directly from an earlier initializer, but it does not trace through a getter body or a method call, so the moment the read of this.someService happens behind that indirection the compiler lets it through and the failure only shows up at runtime. The scenario is deceptively easy to introduce: a getter that reads an injected service is defined below the inject() call, someone later adds a small convenience field above the getter that references it, and the class breaks at construction time even though nothing about the change looks suspicious. Keeping every inject() call at the very top of the class removes the ordering concern entirely, because every dependency is guaranteed to exist before any other field, getter, method, or constructor statement runs.",
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/eslint-plugin",
-  "version": "22.0.1-alpha.16",
+  "version": "22.0.1-alpha.18",
   "description": "ESLint plugin for Angular applications, following https://angular.dev/style-guide",
   "license": "MIT",
   "main": "dist/index.js",
@@ -20,11 +20,11 @@
   ],
   "dependencies": {
     "ts-api-utils": "^2.1.0",
-    "@angular-eslint/bundled-angular-compiler": "22.0.1-alpha.16",
-    "@angular-eslint/utils": "22.0.1-alpha.16"
+    "@angular-eslint/bundled-angular-compiler": "22.0.1-alpha.18",
+    "@angular-eslint/utils": "22.0.1-alpha.18"
   },
   "devDependencies": {
-    "@angular-eslint/test-utils": "22.0.1-alpha.16"
+    "@angular-eslint/test-utils": "22.0.1-alpha.18"
   },
   "peerDependencies": {
     "@typescript-eslint/utils": "^8.0.0",