@angular-eslint/eslint-plugin 22.0.1-alpha.9 → 22.1.0

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 |  |  |  |
@@ -74,6 +75,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

@@ -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;
         };
@@ -102,6 +105,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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuJA,kBAsDE"}

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"));
@@ -80,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,
@@ -91,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,
@@ -116,6 +119,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/consistent-component-styles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"consistent-component-styles.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-component-styles.ts"],"names":[],"mappings":"AAIA,KAAK,IAAI,GAAG,OAAO,GAAG,QAAQ,CAAC;AAC/B,MAAM,MAAM,OAAO,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AACnC,MAAM,MAAM,UAAU,GAClB,gBAAgB,GAChB,iBAAiB,GACjB,aAAa,GACb,cAAc,CAAC;AACnB,eAAO,MAAM,SAAS,gCAAgC,CAAC;;;;AAEvD,wBAsHG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}
+{"version":3,"file":"consistent-component-styles.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-component-styles.ts"],"names":[],"mappings":"AAIA,KAAK,IAAI,GAAG,OAAO,GAAG,QAAQ,CAAC;AAC/B,MAAM,MAAM,OAAO,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AACnC,MAAM,MAAM,UAAU,GACpB,gBAAgB,GAAG,iBAAiB,GAAG,aAAa,GAAG,cAAc,CAAC;AACxE,eAAO,MAAM,SAAS,gCAAgC,CAAC;;;;AAEvD,wBAsHG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

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/dist/rules/no-empty-lifecycle-method.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-empty-lifecycle-method.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-lifecycle-method.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAClB,wBAAwB,GACxB,8BAA8B,CAAC;AACnC,eAAO,MAAM,SAAS,8BAA8B,CAAC;;;;AAErD,wBAuFG;AAYH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}
+{"version":3,"file":"no-empty-lifecycle-method.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-lifecycle-method.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GACpB,wBAAwB,GAAG,8BAA8B,CAAC;AAC5D,eAAO,MAAM,SAAS,8BAA8B,CAAC;;;;AAErD,wBAuFG;AAYH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/prefer-on-push-component-change-detection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prefer-on-push-component-change-detection.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-on-push-component-change-detection.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAClB,sCAAsC,GACtC,8BAA8B,CAAC;AACnC,eAAO,MAAM,SAAS,8CAA8C,CAAC;;;;AAKrE,wBAoEG;AAEH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}
+{"version":3,"file":"prefer-on-push-component-change-detection.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-on-push-component-change-detection.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GACpB,sCAAsC,GAAG,8BAA8B,CAAC;AAC1E,eAAO,MAAM,SAAS,8CAA8C,CAAC;;;;AAKrE,wBAoEG;AAEH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}

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/dist/rules/use-component-view-encapsulation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-component-view-encapsulation.d.ts","sourceRoot":"","sources":["../../src/rules/use-component-view-encapsulation.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAClB,+BAA+B,GAC/B,oCAAoC,CAAC;AACzC,eAAO,MAAM,SAAS,qCAAqC,CAAC;;;;AAG5D,wBAwDG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}
+{"version":3,"file":"use-component-view-encapsulation.d.ts","sourceRoot":"","sources":["../../src/rules/use-component-view-encapsulation.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GACpB,+BAA+B,GAAG,oCAAoC,CAAC;AACzE,eAAO,MAAM,SAAS,qCAAqC,CAAC;;;;AAG5D,wBAwDG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/eslint-plugin",
-  "version": "22.0.1-alpha.9",
+  "version": "22.1.0",
   "description": "ESLint plugin for Angular applications, following https://angular.dev/style-guide",
   "license": "MIT",
   "main": "dist/index.js",
@@ -10,6 +10,7 @@
     "url": "https://github.com/angular-eslint/angular-eslint.git",
     "directory": "packages/eslint-plugin"
   },
+  "bugs": "https://github.com/angular-eslint/angular-eslint/issues",
   "files": [
     "dist",
     "!**/*.tsbuildinfo",
@@ -19,11 +20,11 @@
   ],
   "dependencies": {
     "ts-api-utils": "^2.1.0",
-    "@angular-eslint/bundled-angular-compiler": "22.0.1-alpha.9",
-    "@angular-eslint/utils": "22.0.1-alpha.9"
+    "@angular-eslint/bundled-angular-compiler": "22.1.0",
+    "@angular-eslint/utils": "22.1.0"
   },
   "devDependencies": {
-    "@angular-eslint/test-utils": "22.0.1-alpha.9"
+    "@angular-eslint/test-utils": "22.1.0"
   },
   "peerDependencies": {
     "@typescript-eslint/utils": "^8.0.0",