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

package/README.md

@@ -74,6 +74,7 @@ The premade flat configs that combine these rules are provided by the umbrella [
 | [`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 components do not opt out of the default `ChangeDetectionStrategy.OnPush` change detection strategy | :white_check_mark: |  | :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: |
+| [`prefer-service-decorator`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-service-decorator.md) | Prefer the `@Service()` decorator over `@Injectable({ providedIn: 'root' })` |  | :wrench: |  |
 | [`prefer-signal-model`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-signal-model.md) | Use `model` instead of `input` and `output` for two-way bindings |  | :wrench: |  |
 | [`prefer-signals`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-signals.md) | Use readonly signals instead of `@Input()`, `@ViewChild()` and other legacy decorators |  | :wrench: |  |
 | [`prefer-standalone`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-standalone.md) | Ensures Components, Directives and Pipes do not opt out of standalone. | :white_check_mark: |  | :bulb: |

package/dist/index.d.ts

@@ -102,6 +102,9 @@ declare const _default: {
         "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> & {
             name: string;
         };
+        "prefer-service-decorator": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferServiceDecorator", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         "prefer-signal-model": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferSignalModel", [], 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiJA,kBAoDE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoJA,kBAqDE"}

package/dist/index.js

@@ -61,6 +61,7 @@ const prefer_host_metadata_property_1 = __importStar(require("./rules/prefer-hos
 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_service_decorator_1 = __importStar(require("./rules/prefer-service-decorator"));
 const prefer_signal_model_1 = __importStar(require("./rules/prefer-signal-model"));
 const prefer_inject_1 = __importStar(require("./rules/prefer-inject"));
 const prefer_signals_1 = __importStar(require("./rules/prefer-signals"));
@@ -116,6 +117,7 @@ module.exports = {
         [prefer_on_push_component_change_detection_1.RULE_NAME]: prefer_on_push_component_change_detection_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,
+        [prefer_service_decorator_1.RULE_NAME]: prefer_service_decorator_1.default,
         [prefer_signal_model_1.RULE_NAME]: prefer_signal_model_1.default,
         [prefer_signals_1.RULE_NAME]: prefer_signals_1.default,
         [prefer_standalone_1.RULE_NAME]: prefer_standalone_1.default,

package/dist/rules/prefer-service-decorator.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'preferServiceDecorator';
+export declare const RULE_NAME = "prefer-service-decorator";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferServiceDecorator", [], 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=prefer-service-decorator.d.ts.map

package/dist/rules/prefer-service-decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-service-decorator.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-service-decorator.ts"],"names":[],"mappings":"AAaA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AAEzB,MAAM,MAAM,UAAU,GAAG,wBAAwB,CAAC;AAElD,eAAO,MAAM,SAAS,6BAA6B,CAAC;;;;AAEpD,wBAwFG;AA0DH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/prefer-service-decorator.js

@@ -0,0 +1,101 @@
+"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 = 'prefer-service-decorator';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: "Prefer the `@Service()` decorator over `@Injectable({ providedIn: 'root' })`",
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferServiceDecorator: "Use the `@Service()` decorator instead of `@Injectable({ providedIn: 'root' })`",
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            [utils_1.Selectors.INJECTABLE_CLASS_DECORATOR](node) {
+                const { expression } = node;
+                if (!utils_1.ASTUtils.isCallExpression(expression) ||
+                    expression.arguments.length !== 1) {
+                    return;
+                }
+                const [argument] = expression.arguments;
+                if (!utils_1.ASTUtils.isObjectExpression(argument)) {
+                    return;
+                }
+                const migration = getMetadataMigration(argument);
+                if (!migration) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'preferServiceDecorator',
+                    fix: (fixer) => {
+                        const fixes = [
+                            // `@Injectable(...)` => `@Service(...)`.
+                            fixer.replaceText(expression.callee, 'Service'),
+                            // Migrate the `Injectable` import to `Service`.
+                            ...utils_1.RuleFixes.getImportReplaceFix({
+                                fixer,
+                                fromName: 'Injectable',
+                                moduleName: '@angular/core',
+                                node,
+                                sourceCode: context.sourceCode,
+                                toName: 'Service',
+                            }),
+                        ];
+                        switch (migration.type) {
+                            // Only `providedIn: 'root'`, so drop the whole metadata object.
+                            case 'drop-metadata': {
+                                fixes.push(fixer.remove(argument));
+                                break;
+                            }
+                            // Keep the factory, but rename `useFactory` => `factory` and drop
+                            // `providedIn: 'root'` (which `@Service()` implies).
+                            case 'rewrite-factory': {
+                                fixes.push(fixer.replaceText(migration.useFactoryProperty.key, 'factory'), utils_1.RuleFixes.getNodeToCommaRemoveFix(context.sourceCode, migration.providedInProperty, fixer));
+                                break;
+                            }
+                        }
+                        return fixes.filter(utils_1.isNotNullOrUndefined);
+                    },
+                });
+            },
+        };
+    },
+});
+/**
+ * `@Service()` only models `providedIn: 'root'` (implicit) and accepts a
+ * `factory` (which maps from `useFactory`). Any other provider metadata
+ * (`useClass`, `useExisting`, `useValue`, `deps`, ...) has no equivalent, so we
+ * bail out and leave such `@Injectable`s untouched for now.
+ */
+function getMetadataMigration(argument) {
+    const properties = argument.properties.filter((property) => property.type === utils_2.AST_NODE_TYPES.Property);
+    const providedInProperty = properties.find((property) => utils_2.ASTUtils.getPropertyName(property) === 'providedIn');
+    const useFactoryProperty = properties.find((property) => utils_2.ASTUtils.getPropertyName(property) === 'useFactory');
+    // Bail out unless the only metadata is `providedIn: 'root'` plus an optional
+    // `useFactory`.
+    if (!providedInProperty ||
+        utils_2.ASTUtils.getStaticValue(providedInProperty.value)?.value !==
+            'root' ||
+        properties.length !==
+            [providedInProperty, useFactoryProperty].filter(utils_1.isNotNullOrUndefined)
+                .length) {
+        return undefined;
+    }
+    return useFactoryProperty
+        ? { type: 'rewrite-factory', providedInProperty, useFactoryProperty }
+        : { type: 'drop-metadata' };
+}
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Angular 22 introduced the `@Service()` decorator as a concise shorthand for `@Injectable({ providedIn: 'root' })`, the most common way to declare a tree-shakable, application-wide service. Using `@Service()` removes the boilerplate of the metadata object while expressing the exact same intent. Because `providedIn: 'root'` is exactly what `@Service()` implies, this migration is safe and behavior-preserving: the `providedIn: 'root'` entry is dropped, and a `useFactory` is preserved by renaming it to `@Service()`'s `factory` option. Services that rely on other provider metadata (`useClass`, `useExisting`, `useValue`, `deps`) or a different `providedIn` value (`'platform'`, `'any'`, a specific module) have no `@Service()` equivalent and are intentionally left untouched.",
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/eslint-plugin",
-  "version": "22.0.1-alpha.15",
+  "version": "22.0.1-alpha.16",
   "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.15",
-    "@angular-eslint/utils": "22.0.1-alpha.15"
+    "@angular-eslint/bundled-angular-compiler": "22.0.1-alpha.16",
+    "@angular-eslint/utils": "22.0.1-alpha.16"
   },
   "devDependencies": {
-    "@angular-eslint/test-utils": "22.0.1-alpha.15"
+    "@angular-eslint/test-utils": "22.0.1-alpha.16"
   },
   "peerDependencies": {
     "@typescript-eslint/utils": "^8.0.0",