@depup/angular-eslint__eslint-plugin 21.3.1-depup.0 → 22.1.0-depup.1

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/angular-eslint__eslint-plugin
 
 | Field | Value |
 |-------|-------|
-| Original | [@angular-eslint/eslint-plugin](https://www.npmjs.com/package/@angular-eslint/eslint-plugin) @ 21.3.1 |
-| Processed | 2026-03-22 |
+| Original | [@angular-eslint/eslint-plugin](https://www.npmjs.com/package/@angular-eslint/eslint-plugin) @ 22.1.0 |
+| Processed | 2026-07-21 |
 | Smoke test | passed |
 | Deps updated | 1 |
 

package/changes.json

@@ -5,6 +5,6 @@
       "to": "^2.5.0"
     }
   },
-  "timestamp": "2026-03-22T00:36:53.681Z",
+  "timestamp": "2026-07-21T19:23:52.068Z",
   "totalUpdated": 1
 }

package/dist/index.d.ts

@@ -1,78 +1,4 @@
 declare const _default: {
-    configs: {
-        all: {
-            parser: string;
-            plugins: string[];
-            rules: {
-                "@angular-eslint/component-class-suffix": string;
-                "@angular-eslint/component-max-inline-declarations": string;
-                "@angular-eslint/component-selector": string;
-                "@angular-eslint/computed-must-return": string;
-                "@angular-eslint/consistent-component-styles": string;
-                "@angular-eslint/contextual-decorator": string;
-                "@angular-eslint/contextual-lifecycle": string;
-                "@angular-eslint/directive-class-suffix": string;
-                "@angular-eslint/directive-selector": string;
-                "@angular-eslint/no-async-lifecycle-method": string;
-                "@angular-eslint/no-attribute-decorator": string;
-                "@angular-eslint/no-developer-preview": string;
-                "@angular-eslint/no-duplicates-in-metadata-arrays": string;
-                "@angular-eslint/no-empty-lifecycle-method": string;
-                "@angular-eslint/no-experimental": string;
-                "@angular-eslint/no-forward-ref": string;
-                "@angular-eslint/no-implicit-take-until-destroyed": string;
-                "@angular-eslint/no-input-prefix": string;
-                "@angular-eslint/no-input-rename": string;
-                "@angular-eslint/no-inputs-metadata-property": string;
-                "@angular-eslint/no-lifecycle-call": string;
-                "@angular-eslint/no-output-native": string;
-                "@angular-eslint/no-output-on-prefix": string;
-                "@angular-eslint/no-output-rename": string;
-                "@angular-eslint/no-outputs-metadata-property": string;
-                "@angular-eslint/no-pipe-impure": string;
-                "@angular-eslint/no-queries-metadata-property": string;
-                "@angular-eslint/no-uncalled-signals": string;
-                "@angular-eslint/pipe-prefix": string;
-                "@angular-eslint/prefer-host-metadata-property": 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;
-                "@angular-eslint/prefer-signal-model": string;
-                "@angular-eslint/prefer-signals": string;
-                "@angular-eslint/prefer-standalone": string;
-                "@angular-eslint/relative-url-prefix": string;
-                "@angular-eslint/require-lifecycle-on-prototype": string;
-                "@angular-eslint/require-localize-metadata": string;
-                "@angular-eslint/runtime-localize": string;
-                "@angular-eslint/sort-keys-in-type-decorator": string;
-                "@angular-eslint/sort-lifecycle-methods": string;
-                "@angular-eslint/use-component-selector": string;
-                "@angular-eslint/use-component-view-encapsulation": string;
-                "@angular-eslint/use-injectable-provided-in": string;
-                "@angular-eslint/use-lifecycle-interface": string;
-                "@angular-eslint/use-pipe-transform-interface": string;
-            };
-        };
-        recommended: {
-            parser: string;
-            plugins: string[];
-            rules: {
-                "@angular-eslint/contextual-lifecycle": string;
-                "@angular-eslint/no-empty-lifecycle-method": string;
-                "@angular-eslint/no-input-rename": string;
-                "@angular-eslint/no-inputs-metadata-property": string;
-                "@angular-eslint/no-output-native": string;
-                "@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;
-            };
-        };
-    };
     rules: {
         "component-class-suffix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"componentClassSuffix", import("./rules/component-class-suffix").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
@@ -101,13 +27,13 @@ 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;
         };
-        "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> & {
+        "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-attribute-decorator": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noAttributeDecorator", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        "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;
         };
-        "no-conflicting-lifecycle": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-conflicting-lifecycle").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        "no-attribute-decorator": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noAttributeDecorator", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
         "no-developer-preview": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noDeveloperPreview", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
@@ -179,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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuJA,kBAyDE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuJA,kBAsDE"}

package/dist/index.js

@@ -32,11 +32,6 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const all_json_1 = __importDefault(require("./configs/all.json"));
-const recommended_json_1 = __importDefault(require("./configs/recommended.json"));
 const component_class_suffix_1 = __importStar(require("./rules/component-class-suffix"));
 const component_max_inline_declarations_1 = __importStar(require("./rules/component-max-inline-declarations"));
 const component_selector_1 = __importStar(require("./rules/component-selector"));
@@ -47,7 +42,6 @@ const directive_class_suffix_1 = __importStar(require("./rules/directive-class-s
 const directive_selector_1 = __importStar(require("./rules/directive-selector"));
 const no_async_lifecycle_method_1 = __importStar(require("./rules/no-async-lifecycle-method"));
 const no_attribute_decorator_1 = __importStar(require("./rules/no-attribute-decorator"));
-const no_conflicting_lifecycle_1 = __importStar(require("./rules/no-conflicting-lifecycle"));
 const no_duplicates_in_metadata_arrays_1 = __importStar(require("./rules/no-duplicates-in-metadata-arrays"));
 const no_empty_lifecycle_method_1 = __importStar(require("./rules/no-empty-lifecycle-method"));
 const no_forward_ref_1 = __importStar(require("./rules/no-forward-ref"));
@@ -67,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"));
@@ -86,11 +81,8 @@ 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 = {
-    configs: {
-        all: all_json_1.default,
-        recommended: recommended_json_1.default,
-    },
     rules: {
         [component_class_suffix_1.RULE_NAME]: component_class_suffix_1.default,
         [component_max_inline_declarations_1.RULE_NAME]: component_max_inline_declarations_1.default,
@@ -101,9 +93,9 @@ 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_conflicting_lifecycle_1.RULE_NAME]: no_conflicting_lifecycle_1.default,
         [no_developer_preview_1.RULE_NAME]: no_developer_preview_1.default,
         [no_duplicates_in_metadata_arrays_1.RULE_NAME]: no_duplicates_in_metadata_arrays_1.default,
         [no_empty_lifecycle_method_1.RULE_NAME]: no_empty_lifecycle_method_1.default,
@@ -127,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/contextual-lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contextual-lifecycle.d.ts","sourceRoot":"","sources":["../../src/rules/contextual-lifecycle.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,qBAAqB,CAAC;AAC/C,eAAO,MAAM,SAAS,yBAAyB,CAAC;;;;AAEhD,wBA8DG;AAEH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}
+{"version":3,"file":"contextual-lifecycle.d.ts","sourceRoot":"","sources":["../../src/rules/contextual-lifecycle.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,qBAAqB,CAAC;AAC/C,eAAO,MAAM,SAAS,yBAAyB,CAAC;;;;AAEhD,wBAiEG;AAEH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}

package/dist/rules/contextual-lifecycle.js

@@ -53,6 +53,9 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             [utils_1.Selectors.PIPE_CLASS_DECORATOR](node) {
                 checkContext(node, utils_1.ASTUtils.AngularClassDecorators.Pipe);
             },
+            [utils_1.Selectors.SERVICE_CLASS_DECORATOR](node) {
+                checkContext(node, utils_1.ASTUtils.AngularClassDecorators.Service);
+            },
         };
     },
 });

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-async-lifecycle-method.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-async-lifecycle-method.d.ts","sourceRoot":"","sources":["../../src/rules/no-async-lifecycle-method.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,wBAAwB,CAAC;AAClD,eAAO,MAAM,SAAS,8BAA8B,CAAC;;;;AAErD,wBAyCG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}
+{"version":3,"file":"no-async-lifecycle-method.d.ts","sourceRoot":"","sources":["../../src/rules/no-async-lifecycle-method.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,wBAAwB,CAAC;AAClD,eAAO,MAAM,SAAS,8BAA8B,CAAC;;;;AAErD,wBA0CG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/no-async-lifecycle-method.js

@@ -24,6 +24,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             'Injectable',
             'NgModule',
             'Pipe',
+            'Service',
         ]);
         const angularLifecycleMethodsPattern = (0, utils_1.toPattern)([
             ...utils_1.ASTUtils.ANGULAR_LIFECYCLE_METHODS,

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,wBAsFG;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/no-empty-lifecycle-method.js

@@ -28,6 +28,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             'Injectable',
             'NgModule',
             'Pipe',
+            'Service',
         ]);
         const angularLifecycleMethodsPattern = (0, utils_1.toPattern)([
             ...utils_1.ASTUtils.ANGULAR_LIFECYCLE_METHODS,

package/dist/rules/no-implicit-take-until-destroyed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-implicit-take-until-destroyed.d.ts","sourceRoot":"","sources":["../../src/rules/no-implicit-take-until-destroyed.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,8BAA8B,CAAC;AACxD,eAAO,MAAM,SAAS,qCAAqC,CAAC;;;;AAO5D,wBAgCG;AAqEH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}
+{"version":3,"file":"no-implicit-take-until-destroyed.d.ts","sourceRoot":"","sources":["../../src/rules/no-implicit-take-until-destroyed.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,8BAA8B,CAAC;AACxD,eAAO,MAAM,SAAS,qCAAqC,CAAC;;;;AAO5D,wBAgCG;AAwMH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}

package/dist/rules/no-implicit-take-until-destroyed.js

@@ -55,6 +55,17 @@ function isInInjectionContext(node) {
                 return true;
             }
         }
+        if (isNonConstructorMethod(current)) {
+            const classDeclaration = utils_1.ASTUtils.getNearestNodeFrom(current, utils_1.ASTUtils.isClassDeclaration);
+            if (classDeclaration) {
+                const decorator = utils_1.ASTUtils.getAngularClassDecorator(classDeclaration);
+                if (decorator &&
+                    decorator !== 'NgModule' &&
+                    isMethodCalledFromInjectionContext(current, classDeclaration)) {
+                    return true;
+                }
+            }
+        }
         current = current.parent;
     }
     return false;
@@ -62,6 +73,78 @@ function isInInjectionContext(node) {
 function isConstructorMethod(node) {
     return (node.type === utils_2.AST_NODE_TYPES.MethodDefinition && node.kind === 'constructor');
 }
+function isNonConstructorMethod(node) {
+    return (node.type === utils_2.AST_NODE_TYPES.MethodDefinition && node.kind !== 'constructor');
+}
+function getMethodName(node) {
+    if (node.key.type === utils_2.AST_NODE_TYPES.Identifier ||
+        node.key.type === utils_2.AST_NODE_TYPES.PrivateIdentifier) {
+        return node.key.name;
+    }
+    return null;
+}
+function isMethodCalledFromInjectionContext(method, classDeclaration) {
+    const methodName = getMethodName(method);
+    if (!methodName) {
+        return false;
+    }
+    const isPrivateField = method.key.type === utils_2.AST_NODE_TYPES.PrivateIdentifier;
+    for (const member of classDeclaration.body.body) {
+        if (!isConstructorMethod(member) &&
+            !utils_1.ASTUtils.isPropertyDefinition(member)) {
+            continue;
+        }
+        if (containsCallToMethod(member, methodName, isPrivateField)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isASTNode(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        'type' in value &&
+        typeof value.type === 'string');
+}
+function containsCallToMethod(node, methodName, isPrivateField) {
+    if (node.type === utils_2.AST_NODE_TYPES.CallExpression &&
+        node.callee.type === utils_2.AST_NODE_TYPES.MemberExpression) {
+        const { object, property } = node.callee;
+        if (object.type === utils_2.AST_NODE_TYPES.ThisExpression) {
+            if (isPrivateField &&
+                property.type === utils_2.AST_NODE_TYPES.PrivateIdentifier &&
+                property.name === methodName) {
+                return true;
+            }
+            if (!isPrivateField &&
+                property.type === utils_2.AST_NODE_TYPES.Identifier &&
+                property.name === methodName) {
+                return true;
+            }
+        }
+    }
+    for (const key of Object.keys(node)) {
+        if (key === 'parent')
+            continue;
+        const child = node[key];
+        if (child && typeof child === 'object') {
+            if (Array.isArray(child)) {
+                for (const item of child) {
+                    if (isASTNode(item) &&
+                        containsCallToMethod(item, methodName, isPrivateField)) {
+                        return true;
+                    }
+                }
+            }
+            else if (isASTNode(child)) {
+                if (containsCallToMethod(child, methodName, isPrivateField)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
 function isInFactoryFunction(node) {
     if (node.type !== utils_2.AST_NODE_TYPES.ArrowFunctionExpression &&
         node.type !== utils_2.AST_NODE_TYPES.FunctionExpression) {
@@ -79,5 +162,5 @@ function isInFactoryFunction(node) {
     return false;
 }
 exports.RULE_DOCS_EXTENSION = {
-    rationale: `The \`takeUntilDestroyed()\` operator can automatically infer the current component's or directive's \`DestroyRef\` only when called within an injection context — specifically in constructors or field initializers of classes decorated with \`@Component\`, \`@Directive\`, \`@Injectable\`, or \`@Pipe\`, or in factory functions (\`useFactory\` in providers or \`factory\` in InjectionTokens). When used in lifecycle methods like \`ngOnInit()\` or \`ngAfterViewInit()\`, in regular methods, in constructors of plain classes not managed by Angular's DI system, or in \`@NgModule\` classes (which don't support the \`ngOnDestroy\` lifecycle), the injection context is not available, and \`takeUntilDestroyed()\` will throw a runtime error: "NG0203: inject() must be called from an injection context." To fix this, inject \`DestroyRef\` using \`inject(DestroyRef)\` and pass it explicitly: \`takeUntilDestroyed(this.destroyRef)\`.`,
+    rationale: `The \`takeUntilDestroyed()\` operator can automatically infer the current component's or directive's \`DestroyRef\` only when called within an injection context — specifically in constructors or field initializers of classes decorated with \`@Component\`, \`@Directive\`, \`@Injectable\`, \`@Pipe\`, or \`@Service\`, or in factory functions (\`useFactory\` in providers or \`factory\` in InjectionTokens). When used in lifecycle methods like \`ngOnInit()\` or \`ngAfterViewInit()\`, in regular methods, in constructors of plain classes not managed by Angular's DI system, or in \`@NgModule\` classes (which don't support the \`ngOnDestroy\` lifecycle), the injection context is not available, and \`takeUntilDestroyed()\` will throw a runtime error: "NG0203: inject() must be called from an injection context." To fix this, inject \`DestroyRef\` using \`inject(DestroyRef)\` and pass it explicitly: \`takeUntilDestroyed(this.destroyRef)\`.`,
 };

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

@@ -1 +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,wBAkGG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}
+{"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,wBAmGG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/prefer-inject.js

@@ -25,6 +25,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             'Directive',
             'Injectable',
             'Pipe',
+            'Service',
         ]);
         function shouldReportParameter(param) {
             let actualParam = param;

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

@@ -1,5 +1,5 @@
 export type Options = [];
-export type MessageIds = 'preferOnPushComponentChangeDetection' | 'suggestAddChangeDetectionOnPush';
+export type MessageIds = 'preferOnPushComponentChangeDetection' | 'suggestRemoveChangeDetection';
 export declare const RULE_NAME = "prefer-on-push-component-change-detection";
 declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [], import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;

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,iCAAiC,CAAC;AACtC,eAAO,MAAM,SAAS,8CAA8C,CAAC;;;;AAKrE,wBAuEG;AAYH,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-on-push-component-change-detection.js

@@ -11,54 +11,48 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: `Ensures component's \`${METADATA_PROPERTY_NAME}\` is set to \`${STRATEGY_ON_PUSH}\``,
+            description: `Ensures components do not opt out of the default \`${STRATEGY_ON_PUSH}\` change detection strategy`,
+            recommended: 'recommended',
         },
         hasSuggestions: true,
         schema: [],
         messages: {
-            preferOnPushComponentChangeDetection: `The component's \`${METADATA_PROPERTY_NAME}\` value should be set to \`${STRATEGY_ON_PUSH}\``,
-            suggestAddChangeDetectionOnPush: `Add \`${STRATEGY_ON_PUSH}\``,
+            preferOnPushComponentChangeDetection: `Components should not opt out of the default \`${STRATEGY_ON_PUSH}\` change detection strategy`,
+            suggestRemoveChangeDetection: `Remove \`${METADATA_PROPERTY_NAME}\` to use the default (\`${STRATEGY_ON_PUSH}\`)`,
         },
     },
     defaultOptions: [],
     create(context) {
+        const sourceCode = context.sourceCode;
         const changeDetectionMetadataProperty = utils_1.Selectors.metadataProperty(METADATA_PROPERTY_NAME);
-        const withoutChangeDetectionDecorator = `${utils_1.Selectors.COMPONENT_CLASS_DECORATOR}:matches([expression.arguments.length=0], [expression.arguments.0.type='ObjectExpression']:not(:has(${changeDetectionMetadataProperty})))`;
-        const nonChangeDetectionOnPushProperty = `${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} > CallExpression > ObjectExpression > ${changeDetectionMetadataProperty}:matches([value.type='Identifier'][value.name='undefined'], [value.object.name='ChangeDetectionStrategy'][value.property.name!='OnPush'])`;
-        const selectors = [
-            withoutChangeDetectionDecorator,
-            nonChangeDetectionOnPushProperty,
-        ].join(',');
+        /**
+         * As of Angular v22 OnPush is the default change detection strategy, so a
+         * component only needs to be reported when it explicitly opts out of it by
+         * setting a non-OnPush `ChangeDetectionStrategy` member (e.g. `Eager`, or
+         * the deprecated `Default`). Omitting `changeDetection` entirely, or setting
+         * it to `ChangeDetectionStrategy.OnPush`, is the desired default and is not
+         * reported.
+         */
+        const onPushOptOutProperty = `${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} > CallExpression > ObjectExpression > ${changeDetectionMetadataProperty}[value.object.name='ChangeDetectionStrategy'][value.property.name!='OnPush']`;
         return {
-            [selectors](node) {
+            [onPushOptOutProperty](node) {
+                const { value } = node;
+                // The selector guarantees a `ChangeDetectionStrategy.<member>` value;
+                // this narrows the type for the fixer.
+                if (!utils_1.ASTUtils.isMemberExpression(value)) {
+                    return;
+                }
                 context.report({
-                    node: nodeToReport(node),
+                    node: value.property,
                     messageId: 'preferOnPushComponentChangeDetection',
                     suggest: [
                         {
-                            messageId: 'suggestAddChangeDetectionOnPush',
+                            messageId: 'suggestRemoveChangeDetection',
                             fix: (fixer) => {
-                                if (utils_1.ASTUtils.isProperty(node)) {
-                                    return [
-                                        utils_1.RuleFixes.getImportAddFix({
-                                            fixer,
-                                            importName: 'ChangeDetectionStrategy',
-                                            moduleName: '@angular/core',
-                                            node: node.parent.parent.parent.parent,
-                                        }),
-                                        utils_1.ASTUtils.isMemberExpression(node.value)
-                                            ? fixer.replaceText(node.value.property, 'OnPush')
-                                            : fixer.replaceText(node.value, STRATEGY_ON_PUSH),
-                                    ].filter(utils_1.isNotNullOrUndefined);
-                                }
+                                const importDeclarations = utils_1.ASTUtils.getImportDeclarations(node, '@angular/core') ?? [];
                                 return [
-                                    utils_1.RuleFixes.getImportAddFix({
-                                        fixer,
-                                        importName: 'ChangeDetectionStrategy',
-                                        moduleName: '@angular/core',
-                                        node: node.parent,
-                                    }),
-                                    utils_1.RuleFixes.getDecoratorPropertyAddFix(node, fixer, `${METADATA_PROPERTY_NAME}: ${STRATEGY_ON_PUSH}`),
+                                    utils_1.RuleFixes.getNodeToCommaRemoveFix(sourceCode, node, fixer),
+                                    utils_1.RuleFixes.getImportRemoveFix(sourceCode, importDeclarations, 'ChangeDetectionStrategy', fixer),
                                 ].filter(utils_1.isNotNullOrUndefined);
                             },
                         },
@@ -68,14 +62,6 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         };
     },
 });
-function nodeToReport(node) {
-    if (!utils_1.ASTUtils.isProperty(node)) {
-        return node;
-    }
-    return utils_1.ASTUtils.isMemberExpression(node.value)
-        ? node.value.property
-        : node.value;
-}
 exports.RULE_DOCS_EXTENSION = {
-    rationale: `By default, Angular's change detection checks every component on every change detection cycle, which can involve thousands of checks per second in a large application. OnPush change detection strategy is a performance optimization that tells Angular to only check a component when: (1) its input properties receive new references, (2) an event originates from the component or its children, or (3) change detection is manually triggered. This dramatically reduces the number of change detection runs, improving application performance. OnPush pairs well with immutable data patterns and Angular signals, and is considered a best practice for most components. However, you must be careful to use immutable data patterns (creating new object references when data changes) for OnPush to work correctly.`,
+    rationale: `As of Angular v22, \`${STRATEGY_ON_PUSH}\` is the default change detection strategy: a component that does not specify \`${METADATA_PROPERTY_NAME}\` is checked using OnPush. This brings new code in line with zoneless being the default and with Angular's goal of performance by default, and means it is no longer necessary to set \`${STRATEGY_ON_PUSH}\` explicitly. The previous default, \`ChangeDetectionStrategy.Default\`, has been renamed to \`ChangeDetectionStrategy.Eager\`. When you run \`ng update\`, the v22 migration adds an explicit \`ChangeDetectionStrategy.Eager\` to existing components that relied on the old implicit default, so that they keep behaving as before.\n\nBecause omitting \`${METADATA_PROPERTY_NAME}\` (or setting it to \`${STRATEGY_ON_PUSH}\`) already gives you OnPush, this rule does not require you to declare it. Instead it reports components that explicitly opt out of OnPush by setting \`ChangeDetectionStrategy.Eager\` (or the deprecated \`ChangeDetectionStrategy.Default\`) — including the components the migration marked as \`Eager\` — so you can review them and adopt OnPush where it is safe to do so. The suggestion removes the \`${METADATA_PROPERTY_NAME}\` property entirely (along with the now-unused \`ChangeDetectionStrategy\` import), relying on the v22 default rather than setting \`${STRATEGY_ON_PUSH}\` explicitly. Note that switching a component from eager checking to OnPush can change its runtime behaviour, so apply the suggestion deliberately and make sure the component uses immutable data patterns (creating new object references when data changes).`,
 };

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": "@depup/angular-eslint__eslint-plugin",
-  "version": "21.3.1-depup.0",
+  "version": "22.1.0-depup.1",
   "description": "ESLint plugin for Angular applications, following https://angular.dev/style-guide (with updated dependencies)",
   "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",
@@ -20,15 +21,15 @@
   ],
   "dependencies": {
     "ts-api-utils": "^2.5.0",
-    "@angular-eslint/bundled-angular-compiler": "21.3.1",
-    "@angular-eslint/utils": "21.3.1"
+    "@angular-eslint/bundled-angular-compiler": "22.1.0",
+    "@angular-eslint/utils": "22.1.0"
   },
   "devDependencies": {
-    "@angular-eslint/test-utils": "21.3.1"
+    "@angular-eslint/test-utils": "22.1.0"
   },
   "peerDependencies": {
-    "@typescript-eslint/utils": "^7.11.0 || ^8.0.0",
-    "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+    "@typescript-eslint/utils": "^8.0.0",
+    "eslint": "^9.0.0 || ^10.0.0",
     "typescript": "*"
   },
   "gitHead": "e2006e5e9c99e5a943d1a999e0efa5247d29ec24",
@@ -49,8 +50,8 @@
     },
     "depsUpdated": 1,
     "originalPackage": "@angular-eslint/eslint-plugin",
-    "originalVersion": "21.3.1",
-    "processedAt": "2026-03-22T00:36:59.588Z",
+    "originalVersion": "22.1.0",
+    "processedAt": "2026-07-21T19:24:01.669Z",
     "smokeTest": "passed"
   }
 }

package/dist/configs/README.md

@@ -1,44 +0,0 @@
-# Premade configs
-
-These configs exist for your convenience. They contain configuration intended to save you time and effort when configuring your project by disabling rules known to conflict with this repository, or cause issues in Angular codebases.
-
-## `all`
-
-Quite simply, this enables all the possible rules from `@angular-eslint/eslint-plugin`. It is unlikely this will be applicable in real-world projects, but some folks find this useful to have as a reference.
-
-## `recommended`
-
-The recommended set is an **_opinionated_** set of Angular-specific rules that we think you should use because:
-
-1. They help you adhere to Angular best practices.
-2. They help catch probable issue vectors in your code.
-
-That being said, it is not the only way to use `@angular-eslint/eslint-plugin`, nor is it the way that will necessarily work 100% for your project/company. It has been built based off of two main things:
-
-1. Angular best practices collected and collated from places like:
-   - [Angular repo](https://github.com/angular/angular).
-   - [Angular documentation](https://angular.dev).
-   - Advice from the Angular Team at Google.
-2. The combined state of community contributed rulesets at the time of creation.
-
-It is strongly encouraged to combine the recommended Angular rules with the recommended configs from `typescript-eslint` (https://typescript-eslint.io/linting/configs/#recommended-configurations), and this is what our schematics will generate for you automatically.
-
-We will not change/add new rules to the recommended set unless we release a major package version (i.e. it is seen as a breaking change).
-
-### Altering the recommended set to suit your project
-
-If you disagree with a rule (or it disagrees with your codebase), consider using your local config to change the rule config so it works for your project.
-
-```cjson
-{
-  "extends": ["plugin:@angular-eslint/recommended"],
-  "rules": {
-    // our project thinks using renaming inputs is ok
-    "@angular-eslint/no-input-rename": "off"
-  }
-}
-```
-
-### Suggesting changes to the recommended set
-
-If you feel _very_, **very**, **_very_** strongly that a specific rule should (or should not) be in the recommended ruleset, please feel free to file an issue along with a **detailed** argument explaining your reasoning. We expect to see you citing concrete evidence supporting why (or why not) a rule is considered best practice. **Please note that if your reasoning is along the lines of "it's what my project/company does", or "I don't like the rule", then we will likely close the request without discussion.**

package/dist/configs/all.json

@@ -1,54 +0,0 @@
-{
-  "parser": "@typescript-eslint/parser",
-  "plugins": ["@angular-eslint"],
-  "rules": {
-    "@angular-eslint/component-class-suffix": "error",
-    "@angular-eslint/component-max-inline-declarations": "error",
-    "@angular-eslint/component-selector": "error",
-    "@angular-eslint/computed-must-return": "error",
-    "@angular-eslint/consistent-component-styles": "error",
-    "@angular-eslint/contextual-decorator": "error",
-    "@angular-eslint/contextual-lifecycle": "error",
-    "@angular-eslint/directive-class-suffix": "error",
-    "@angular-eslint/directive-selector": "error",
-    "@angular-eslint/no-async-lifecycle-method": "error",
-    "@angular-eslint/no-attribute-decorator": "error",
-    "@angular-eslint/no-developer-preview": "error",
-    "@angular-eslint/no-duplicates-in-metadata-arrays": "error",
-    "@angular-eslint/no-empty-lifecycle-method": "error",
-    "@angular-eslint/no-experimental": "error",
-    "@angular-eslint/no-forward-ref": "error",
-    "@angular-eslint/no-implicit-take-until-destroyed": "error",
-    "@angular-eslint/no-input-prefix": "error",
-    "@angular-eslint/no-input-rename": "error",
-    "@angular-eslint/no-inputs-metadata-property": "error",
-    "@angular-eslint/no-lifecycle-call": "error",
-    "@angular-eslint/no-output-native": "error",
-    "@angular-eslint/no-output-on-prefix": "error",
-    "@angular-eslint/no-output-rename": "error",
-    "@angular-eslint/no-outputs-metadata-property": "error",
-    "@angular-eslint/no-pipe-impure": "error",
-    "@angular-eslint/no-queries-metadata-property": "error",
-    "@angular-eslint/no-uncalled-signals": "error",
-    "@angular-eslint/pipe-prefix": "error",
-    "@angular-eslint/prefer-host-metadata-property": "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",
-    "@angular-eslint/prefer-signal-model": "error",
-    "@angular-eslint/prefer-signals": "error",
-    "@angular-eslint/prefer-standalone": "error",
-    "@angular-eslint/relative-url-prefix": "error",
-    "@angular-eslint/require-lifecycle-on-prototype": "error",
-    "@angular-eslint/require-localize-metadata": "error",
-    "@angular-eslint/runtime-localize": "error",
-    "@angular-eslint/sort-keys-in-type-decorator": "error",
-    "@angular-eslint/sort-lifecycle-methods": "error",
-    "@angular-eslint/use-component-selector": "error",
-    "@angular-eslint/use-component-view-encapsulation": "error",
-    "@angular-eslint/use-injectable-provided-in": "error",
-    "@angular-eslint/use-lifecycle-interface": "error",
-    "@angular-eslint/use-pipe-transform-interface": "error"
-  }
-}

package/dist/configs/recommended.json

@@ -1,18 +0,0 @@
-{
-  "parser": "@typescript-eslint/parser",
-  "plugins": ["@angular-eslint"],
-  "rules": {
-    "@angular-eslint/contextual-lifecycle": "error",
-    "@angular-eslint/no-empty-lifecycle-method": "error",
-    "@angular-eslint/no-input-rename": "error",
-    "@angular-eslint/no-inputs-metadata-property": "error",
-    "@angular-eslint/no-output-native": "error",
-    "@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/rules/no-conflicting-lifecycle.d.ts

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

package/dist/rules/no-conflicting-lifecycle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"no-conflicting-lifecycle.d.ts","sourceRoot":"","sources":["../../src/rules/no-conflicting-lifecycle.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAClB,iCAAiC,GACjC,8BAA8B,CAAC;AACnC,eAAO,MAAM,SAAS,6BAA6B,CAAC;;;;AAWpD,wBA8EG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/no-conflicting-lifecycle.js

@@ -1,74 +0,0 @@
-"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 = 'no-conflicting-lifecycle';
-const LIFECYCLE_INTERFACES = [
-    utils_1.ASTUtils.AngularLifecycleInterfaces.DoCheck,
-    utils_1.ASTUtils.AngularLifecycleInterfaces.OnChanges,
-];
-const LIFECYCLE_METHODS = [
-    utils_1.ASTUtils.AngularLifecycleMethods.ngDoCheck,
-    utils_1.ASTUtils.AngularLifecycleMethods.ngOnChanges,
-];
-exports.default = (0, create_eslint_rule_1.createESLintRule)({
-    name: exports.RULE_NAME,
-    meta: {
-        type: 'suggestion',
-        deprecated: true,
-        docs: {
-            description: 'Ensures that directives do not implement conflicting lifecycle interfaces.',
-        },
-        schema: [],
-        messages: {
-            noConflictingLifecycleInterface: `Implementing ${utils_1.ASTUtils.AngularLifecycleInterfaces.DoCheck} and ${utils_1.ASTUtils.AngularLifecycleInterfaces.OnChanges} in a class is not recommended`,
-            noConflictingLifecycleMethod: `Declaring ${utils_1.ASTUtils.AngularLifecycleMethods.ngDoCheck} and ${utils_1.ASTUtils.AngularLifecycleMethods.ngOnChanges} method in a class is not recommended`,
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const validateInterfaces = (node) => {
-            const declaredAngularLifecycleInterfaces = utils_1.ASTUtils.getDeclaredAngularLifecycleInterfaces(node);
-            const hasInterfaceConflictingLifecycle = LIFECYCLE_INTERFACES.every((lifecycleInterface) => declaredAngularLifecycleInterfaces.includes(lifecycleInterface));
-            if (!hasInterfaceConflictingLifecycle)
-                return;
-            const declaredInterfaces = utils_1.ASTUtils.getInterfaces(node);
-            const declaredAngularLifecycleInterfacesNodes = declaredInterfaces.filter((node) => {
-                const interfaceName = utils_1.ASTUtils.getInterfaceName(node);
-                return (interfaceName && utils_1.ASTUtils.isAngularLifecycleInterface(interfaceName));
-            });
-            for (const interFaceNode of declaredAngularLifecycleInterfacesNodes) {
-                context.report({
-                    node: interFaceNode,
-                    messageId: 'noConflictingLifecycleInterface',
-                });
-            }
-        };
-        const validateMethods = (node) => {
-            const declaredAngularLifecycleMethods = utils_1.ASTUtils.getDeclaredAngularLifecycleMethods(node);
-            const hasMethodConflictingLifecycle = LIFECYCLE_METHODS.every((lifecycleMethod) => declaredAngularLifecycleMethods.includes(lifecycleMethod));
-            if (!hasMethodConflictingLifecycle)
-                return;
-            const declaredMethods = utils_1.ASTUtils.getDeclaredMethods(node);
-            const declaredAngularLifecycleMethodNodes = declaredMethods.filter((node) => utils_2.ASTUtils.isIdentifier(node.key) &&
-                utils_1.ASTUtils.isAngularLifecycleMethod(node.key.name));
-            for (const method of declaredAngularLifecycleMethodNodes) {
-                context.report({
-                    node: method,
-                    messageId: 'noConflictingLifecycleMethod',
-                });
-            }
-        };
-        return {
-            ClassDeclaration(node) {
-                validateInterfaces(node);
-                validateMethods(node);
-            },
-        };
-    },
-});
-exports.RULE_DOCS_EXTENSION = {
-    rationale: 'This rule was created with the intent to prevent potential issues when both DoCheck and OnChanges lifecycle hooks are implemented together, as they both deal with change detection and could create confusing or duplicated logic. However, the rule has proven to be overly broad in practice. It triggers whenever a component or directive implements both hooks, regardless of whether they actually conflict or track the same data. In reality, there are legitimate use cases where both hooks can coexist without issues—for instance, using OnChanges to respond to specific input changes while using DoCheck for custom change detection logic on different data. Because the rule cannot accurately determine whether the hooks are actually conflicting (i.e., checking the same variables), it produces false positives and has been removed from the recommended configuration. While the rule was well-intentioned, it should not be relied upon in practice.',
-};