@angular-eslint/eslint-plugin 19.5.1-alpha.1 → 19.5.1-alpha.10

package/README.md

@@ -65,6 +65,7 @@ Please see https://github.com/angular-eslint/angular-eslint for full usage instr
 | [`no-pipe-impure`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-pipe-impure.md) | Disallows the declaration of impure pipes |  |  | :bulb: |
 | [`no-queries-metadata-property`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-queries-metadata-property.md) | Disallows usage of the `queries` metadata property. See more at https://angular.dev/style-guide#style-05-12. |  |  |  |
 | [`pipe-prefix`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/pipe-prefix.md) | Enforce consistent prefix for pipes. |  |  |  |
+| [`prefer-inject`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-inject.md) | Prefer using the inject() function over constructor parameter injection | :white_check_mark: |  |  |
 | [`prefer-on-push-component-change-detection`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-on-push-component-change-detection.md) | Ensures component's `changeDetection` is set to `ChangeDetectionStrategy.OnPush` |  |  | :bulb: |
 | [`prefer-output-emitter-ref`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-output-emitter-ref.md) | Use `OutputEmitterRef` instead of `@Output()` |  |  |  |
 | [`prefer-output-readonly`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-output-readonly.md) | Prefer to declare `@Output`, `OutputEmitterRef` and `OutputRef` as `readonly` since they are not supposed to be reassigned |  |  | :bulb: |

package/dist/configs/all.json

@@ -27,6 +27,7 @@
     "@angular-eslint/no-pipe-impure": "error",
     "@angular-eslint/no-queries-metadata-property": "error",
     "@angular-eslint/pipe-prefix": "error",
+    "@angular-eslint/prefer-inject": "error",
     "@angular-eslint/prefer-on-push-component-change-detection": "error",
     "@angular-eslint/prefer-output-emitter-ref": "error",
     "@angular-eslint/prefer-output-readonly": "error",

package/dist/configs/recommended.json

@@ -12,6 +12,7 @@
     "@angular-eslint/no-output-on-prefix": "error",
     "@angular-eslint/no-output-rename": "error",
     "@angular-eslint/no-outputs-metadata-property": "error",
+    "@angular-eslint/prefer-inject": "error",
     "@angular-eslint/prefer-standalone": "error",
     "@angular-eslint/use-pipe-transform-interface": "error",
     "@angular-eslint/use-lifecycle-interface": "warn"

package/dist/index.d.ts

@@ -29,6 +29,7 @@ declare const _default: {
                 "@angular-eslint/no-pipe-impure": string;
                 "@angular-eslint/no-queries-metadata-property": string;
                 "@angular-eslint/pipe-prefix": string;
+                "@angular-eslint/prefer-inject": string;
                 "@angular-eslint/prefer-on-push-component-change-detection": string;
                 "@angular-eslint/prefer-output-emitter-ref": string;
                 "@angular-eslint/prefer-output-readonly": string;
@@ -61,6 +62,7 @@ declare const _default: {
                 "@angular-eslint/no-output-on-prefix": string;
                 "@angular-eslint/no-output-rename": string;
                 "@angular-eslint/no-outputs-metadata-property": string;
+                "@angular-eslint/prefer-inject": string;
                 "@angular-eslint/prefer-standalone": string;
                 "@angular-eslint/use-pipe-transform-interface": string;
                 "@angular-eslint/use-lifecycle-interface": string;
@@ -102,6 +104,7 @@ declare const _default: {
             additionalSignalCreationFunctions: string[];
         }], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "prefer-standalone": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferStandalone", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "prefer-inject": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferInject", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "prefer-output-emitter-ref": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferOutputEmitterRef", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "prefer-output-readonly": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/prefer-output-readonly").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "relative-url-prefix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"relativeUrlPrefix", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+HA,kBAiDE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkIA,kBAkDE"}

package/dist/index.js

@@ -65,6 +65,7 @@ const pipe_prefix_1 = __importStar(require("./rules/pipe-prefix"));
 const prefer_on_push_component_change_detection_1 = __importStar(require("./rules/prefer-on-push-component-change-detection"));
 const prefer_output_emitter_ref_1 = __importStar(require("./rules/prefer-output-emitter-ref"));
 const prefer_output_readonly_1 = __importStar(require("./rules/prefer-output-readonly"));
+const prefer_inject_1 = __importStar(require("./rules/prefer-inject"));
 const prefer_signals_1 = __importStar(require("./rules/prefer-signals"));
 const prefer_standalone_1 = __importStar(require("./rules/prefer-standalone"));
 const relative_url_prefix_1 = __importStar(require("./rules/relative-url-prefix"));
@@ -112,6 +113,7 @@ module.exports = {
         [prefer_on_push_component_change_detection_1.RULE_NAME]: prefer_on_push_component_change_detection_1.default,
         [prefer_signals_1.RULE_NAME]: prefer_signals_1.default,
         [prefer_standalone_1.RULE_NAME]: prefer_standalone_1.default,
+        [prefer_inject_1.RULE_NAME]: prefer_inject_1.default,
         [prefer_output_emitter_ref_1.RULE_NAME]: prefer_output_emitter_ref_1.default,
         [prefer_output_readonly_1.RULE_NAME]: prefer_output_readonly_1.default,
         [relative_url_prefix_1.RULE_NAME]: relative_url_prefix_1.default,

package/dist/rules/prefer-inject.d.ts

@@ -0,0 +1,6 @@
+export type Options = [];
+export type MessageIds = 'preferInject';
+export declare const RULE_NAME = "prefer-inject";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferInject", [], import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-inject.d.ts.map

package/dist/rules/prefer-inject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-inject.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-inject.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AAEzB,MAAM,MAAM,UAAU,GAAG,cAAc,CAAC;AACxC,eAAO,MAAM,SAAS,kBAAkB,CAAC;;AAEzC,wBA8GG"}

package/dist/rules/prefer-inject.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = 'prefer-inject';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer using the inject() function over constructor parameter injection',
+            recommended: 'recommended',
+        },
+        schema: [],
+        messages: {
+            preferInject: "Prefer using the inject() function over constructor parameter injection. Use Angular's migration schematic to automatically refactor: ng generate @angular/core:inject",
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const angularDecoratorsPattern = (0, utils_1.toPattern)([
+            'Component',
+            'Directive',
+            'Injectable',
+            'Pipe',
+        ]);
+        function shouldReportParameter(param) {
+            let actualParam = param;
+            let hasModifier = false;
+            if (param.type === utils_2.AST_NODE_TYPES.TSParameterProperty) {
+                actualParam = param.parameter;
+                hasModifier = true;
+            }
+            const decorators = (param.type === utils_2.AST_NODE_TYPES.TSParameterProperty
+                ? param.parameter
+                : param).decorators;
+            if (decorators?.some((d) => {
+                const name = utils_1.ASTUtils.getDecoratorName(d);
+                return (name === 'Inject' ||
+                    name === 'Optional' ||
+                    name === 'Self' ||
+                    name === 'SkipSelf' ||
+                    name === 'Host');
+            })) {
+                return true;
+            }
+            if (hasModifier) {
+                return true;
+            }
+            const typeAnnotation = actualParam.typeAnnotation;
+            if (typeAnnotation) {
+                switch (typeAnnotation.typeAnnotation.type) {
+                    case utils_2.AST_NODE_TYPES.TSStringKeyword:
+                    case utils_2.AST_NODE_TYPES.TSNumberKeyword:
+                    case utils_2.AST_NODE_TYPES.TSBooleanKeyword:
+                    case utils_2.AST_NODE_TYPES.TSBigIntKeyword:
+                    case utils_2.AST_NODE_TYPES.TSSymbolKeyword:
+                    case utils_2.AST_NODE_TYPES.TSAnyKeyword:
+                    case utils_2.AST_NODE_TYPES.TSUnknownKeyword:
+                        return false;
+                    default:
+                        return true;
+                }
+            }
+            return false;
+        }
+        return {
+            [`${utils_1.Selectors.decoratorDefinition(angularDecoratorsPattern)} > ClassBody > MethodDefinition[kind="constructor"]`](node) {
+                const params = node.value.params;
+                if (params.length === 0) {
+                    return;
+                }
+                // ignore constructors that only call super() (no parameters to inject)
+                const body = node.value.body?.body ?? [];
+                const onlySuper = body.length === 1 &&
+                    body[0].type === utils_2.AST_NODE_TYPES.ExpressionStatement &&
+                    body[0].expression.type === utils_2.AST_NODE_TYPES.CallExpression &&
+                    body[0].expression.callee.type === utils_2.AST_NODE_TYPES.Super;
+                if (onlySuper && params.length === 0) {
+                    return;
+                }
+                for (const param of params) {
+                    if (shouldReportParameter(param)) {
+                        context.report({ node: param, messageId: 'preferInject' });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/sort-keys-in-type-decorator.js

@@ -138,7 +138,9 @@ function reportAndFix(context, node, messageId, data, properties, expectedOrder,
         fix(fixer) {
             const indentation = utils_1.CommentUtils.getObjectIndentation(sourceCode, objectExpression);
             const propNames = properties.map((p) => p.key.name);
-            const filteredOrder = expectedOrder.filter((name) => propNames.includes(name));
+            const configuredProps = expectedOrder.filter((name) => propNames.includes(name));
+            const unconfiguredProps = propNames.filter((name) => !expectedOrder.includes(name));
+            const filteredOrder = [...configuredProps, ...unconfiguredProps];
             const propInfoMap = utils_1.CommentUtils.extractPropertyComments(sourceCode, properties, objectExpression, indentation);
             const sortedText = utils_1.CommentUtils.buildSortedPropertiesWithComments(filteredOrder, propInfoMap, indentation);
             return fixer.replaceText(objectExpression, `{\n${sortedText}\n${indentation.slice(0, -2)}}`);

package/package.json

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