@angular-eslint/eslint-plugin 21.4.1-alpha.7 → 22.0.0

package/README.md

@@ -4,7 +4,7 @@ Please see https://github.com/angular-eslint/angular-eslint for full usage instr
 
 ## Premade configs
 
-- [Premade configs](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/src/configs)
+The premade flat configs that combine these rules are provided by the umbrella [`angular-eslint`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/angular-eslint/src/configs/README.md) package.
 
 ## Rules
 
@@ -71,7 +71,7 @@ Please see https://github.com/angular-eslint/angular-eslint for full usage instr
 | [`pipe-prefix`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/pipe-prefix.md) | Enforce consistent prefix for pipes. |  |  |  |
 | [`prefer-host-metadata-property`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-host-metadata-property.md) | Use `host` metadata property instead of `@HostBinding` and `HostListener` |  |  |  |
 | [`prefer-inject`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-inject.md) | Prefer using the inject() function over constructor parameter injection | :white_check_mark: |  |  |
-| [`prefer-on-push-component-change-detection`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-on-push-component-change-detection.md) | Ensures component's `changeDetection` is set to `ChangeDetectionStrategy.OnPush` |  |  | :bulb: |
+| [`prefer-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-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: |  |
@@ -96,12 +96,4 @@ Please see https://github.com/angular-eslint/angular-eslint for full usage instr
 
 <!-- begin deprecated rule list -->
 
-### Deprecated
-
-<!-- prettier-ignore-start -->
-| Rule | Replaced by |
-| --- | --- |
-| [`no-conflicting-lifecycle`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-conflicting-lifecycle.md) |  |
-<!-- prettier-ignore-end -->
-
 <!-- end deprecated rule list -->

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;
@@ -107,9 +33,6 @@ declare const _default: {
         "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-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> & {
-            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> & {
             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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiJA,kBAoDE"}

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"));
@@ -87,10 +81,6 @@ const no_developer_preview_1 = __importStar(require("./rules/no-developer-previe
 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"));
 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,
@@ -103,7 +93,6 @@ module.exports = {
         [directive_selector_1.RULE_NAME]: directive_selector_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,

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/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,GAClB,wBAAwB,GACxB,8BAA8B,CAAC;AACnC,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.js

@@ -79,5 +79,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,GAClB,sCAAsC,GACtC,8BAA8B,CAAC;AACnC,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/eslint-plugin",
-  "version": "21.4.1-alpha.7",
+  "version": "22.0.0",
   "description": "ESLint plugin for Angular applications, following https://angular.dev/style-guide",
   "license": "MIT",
   "main": "dist/index.js",
@@ -19,15 +19,15 @@
   ],
   "dependencies": {
     "ts-api-utils": "^2.1.0",
-    "@angular-eslint/bundled-angular-compiler": "21.4.1-alpha.7",
-    "@angular-eslint/utils": "21.4.1-alpha.7"
+    "@angular-eslint/bundled-angular-compiler": "22.0.0",
+    "@angular-eslint/utils": "22.0.0"
   },
   "devDependencies": {
-    "@angular-eslint/test-utils": "21.4.1-alpha.7"
+    "@angular-eslint/test-utils": "22.0.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"

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.',
-};