@depup/angular-eslint__eslint-plugin 22.2.0-depup.0 → 22.4.0-depup.0

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) @ 22.2.0 |
-| Processed | 2026-08-30 |
+| Original | [@angular-eslint/eslint-plugin](https://www.npmjs.com/package/@angular-eslint/eslint-plugin) @ 22.4.0 |
+| Processed | 2026-09-07 |
 | Smoke test | passed |
 | Deps updated | 1 |
 

package/changes.json

@@ -5,6 +5,6 @@
       "to": "^2.5.0"
     }
   },
-  "timestamp": "2026-08-30T16:08:06.033Z",
+  "timestamp": "2026-09-07T16:09:04.652Z",
   "totalUpdated": 1
 }

package/dist/index.d.ts

@@ -27,7 +27,7 @@ declare const _default: {
         "directive-selector": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/directive-selector").MessageIds, import("./rules/directive-selector").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        "inject-at-top": import("@typescript-eslint/utils/ts-eslint").RuleModule<"injectAtTop", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        "inject-at-top": import("@typescript-eslint/utils/ts-eslint").RuleModule<"injectAtTop", import("./rules/inject-at-top").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> & {
@@ -108,7 +108,9 @@ declare const _default: {
         "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> & {
+        "prefer-signal-model": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferSignalModel", [{
+            useTypeChecking: boolean;
+        }], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
         "prefer-signals": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/prefer-signals").MessageIds, [{
@@ -123,6 +125,9 @@ declare const _default: {
         "prefer-standalone": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/prefer-standalone").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        "reactive-context-must-read-signal": import("@typescript-eslint/utils/ts-eslint").RuleModule<"mustReadSignal", import("./rules/reactive-context-must-read-signal").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         "relative-url-prefix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"relativeUrlPrefix", [], 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,kBAsDE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0JA,kBAuDE"}

package/dist/index.js

@@ -82,6 +82,7 @@ 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"));
 const inject_at_top_1 = __importStar(require("./rules/inject-at-top"));
+const reactive_context_must_read_signal_1 = __importStar(require("./rules/reactive-context-must-read-signal"));
 module.exports = {
     rules: {
         [component_class_suffix_1.RULE_NAME]: component_class_suffix_1.default,
@@ -123,6 +124,7 @@ module.exports = {
         [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,
+        [reactive_context_must_read_signal_1.RULE_NAME]: reactive_context_must_read_signal_1.default,
         [relative_url_prefix_1.RULE_NAME]: relative_url_prefix_1.default,
         [require_lifecycle_on_prototype_1.RULE_NAME]: require_lifecycle_on_prototype_1.default,
         [require_localize_metadata_1.RULE_NAME]: require_localize_metadata_1.default,

package/dist/rules/component-class-suffix.js

@@ -28,12 +28,12 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             componentClassSuffix: `Component class names should end with one of these suffixes: {{suffixes}}`,
         },
+        defaultOptions: [
+            {
+                suffixes: ['Component'],
+            },
+        ],
     },
-    defaultOptions: [
-        {
-            suffixes: ['Component'],
-        },
-    ],
     create(context, [{ suffixes }]) {
         return {
             [utils_1.Selectors.COMPONENT_CLASS_DECORATOR](node) {

package/dist/rules/component-max-inline-declarations.js

@@ -38,14 +38,14 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             componentMaxInlineDeclarations: `\`{{propertyType}}\` has too many lines ({{lineCount}}). Maximum allowed is {{max}}`,
         },
+        defaultOptions: [
+            {
+                template: DEFAULT_TEMPLATE_LIMIT,
+                styles: DEFAULT_STYLES_LIMIT,
+                animations: DEFAULT_ANIMATIONS_LIMIT,
+            },
+        ],
     },
-    defaultOptions: [
-        {
-            template: DEFAULT_TEMPLATE_LIMIT,
-            styles: DEFAULT_STYLES_LIMIT,
-            animations: DEFAULT_ANIMATIONS_LIMIT,
-        },
-    ],
     create(context, [{ template = DEFAULT_TEMPLATE_LIMIT, styles = DEFAULT_STYLES_LIMIT, animations = DEFAULT_ANIMATIONS_LIMIT, },]) {
         return {
             [`${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} Property[key.name='template']`]({ value, }) {

package/dist/rules/computed-must-return.js

@@ -15,8 +15,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             computedMissingReturn: 'computed() is missing a return value',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const functionStack = [];
         function enterFunction(node) {

package/dist/rules/consistent-component-styles.js

@@ -24,8 +24,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             useStylesArray: 'Use a `string[]` instead of a `string` for the `styles` property',
             useStylesString: 'Use a `string` instead of a `string[]` for the `styles` property',
         },
+        defaultOptions: ['string'],
     },
-    defaultOptions: ['string'],
     create(context, [mode]) {
         const { COMPONENT_CLASS_DECORATOR, metadataProperty } = utils_1.Selectors;
         const LITERAL_OR_TEMPLATE_LITERAL = ':matches(Literal, TemplateLiteral)';

package/dist/rules/contextual-decorator.js

@@ -15,8 +15,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             contextualDecorator: 'Decorator out of context for "@{{classDecoratorName}}()"',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             'MethodDefinition[kind=/^(get|set|method)$/], PropertyDefinition, TSParameterProperty'(node) {

package/dist/rules/contextual-lifecycle.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             contextualLifecycle: `Angular will not invoke the \`{{methodName}}\` lifecycle method within \`@{{classDecoratorName}}()\` classes`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         function checkContext({ parent }, decorator) {
             const classDeclaration = parent;

package/dist/rules/directive-class-suffix.js

@@ -30,8 +30,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             directiveClassSuffix: `Directive class names should end with one of these suffixes: {{suffixes}}`,
         },
+        defaultOptions: [{ suffixes: DEFAULT_SUFFIXES }],
     },
-    defaultOptions: [{ suffixes: DEFAULT_SUFFIXES }],
     create(context, [{ suffixes }]) {
         return {
             [utils_1.Selectors.DIRECTIVE_CLASS_DECORATOR](node) {

package/dist/rules/inject-at-top.d.ts

@@ -1,7 +1,11 @@
-export type Options = [];
+export type Options = [
+    {
+        readonly additionalInjectFunctions?: readonly string[];
+    }
+];
 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> & {
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"injectAtTop", Options, import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };
 export default _default;

package/dist/rules/inject-at-top.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"inject-at-top.d.ts","sourceRoot":"","sources":["../../src/rules/inject-at-top.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,yBAAyB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;KACxD;CACF,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,aAAa,CAAC;AACvC,eAAO,MAAM,SAAS,kBAAkB,CAAC;;;;AAIzC,wBAyHG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/inject-at-top.js

@@ -5,6 +5,7 @@ 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';
+const DEFAULT_OPTIONS = { additionalInjectFunctions: [] };
 exports.default = (0, create_eslint_rule_1.createESLintRule)({
     name: exports.RULE_NAME,
     meta: {
@@ -12,13 +13,28 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         docs: {
             description: 'Requires inject() calls to be declared at the top of the class, before any other member',
         },
-        schema: [],
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    additionalInjectFunctions: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                        description: 'A list of additional functions which perform injection, such as your own `injectTranslations()` helper. Each entry is a regular expression which must match the whole function name, so plain names such as `injectTranslations` work as well as patterns such as `inject[A-Z].*`.',
+                        uniqueItems: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
         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.',
+            injectAtTop: 'Move this {{functionName}}() 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: [DEFAULT_OPTIONS],
     },
-    defaultOptions: [],
-    create(context) {
+    create(context, [{ additionalInjectFunctions = [] }]) {
         const angularDecoratorsPattern = (0, utils_1.toPattern)([
             'Component',
             'Directive',
@@ -26,14 +42,18 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             'Pipe',
             'Service',
         ]);
-        function hasEagerInject(node) {
+        const injectFunctionsPattern = (0, utils_1.toPattern)([
+            'inject',
+            ...additionalInjectFunctions,
+        ]);
+        function findEagerInjectName(node) {
             if (!node) {
-                return false;
+                return null;
             }
             if (node.type === utils_2.AST_NODE_TYPES.CallExpression &&
                 node.callee.type === utils_2.AST_NODE_TYPES.Identifier &&
-                node.callee.name === 'inject') {
-                return true;
+                injectFunctionsPattern.test(node.callee.name)) {
+                return node.callee.name;
             }
             const isFn = node.type === utils_2.AST_NODE_TYPES.ArrowFunctionExpression ||
                 node.type === utils_2.AST_NODE_TYPES.FunctionExpression;
@@ -41,15 +61,20 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                 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 null;
+            }
+            for (const child of Object.values(node).flat()) {
+                if (child &&
+                    typeof child === 'object' &&
+                    'type' in child &&
+                    child !== node.parent) {
+                    const name = findEagerInjectName(child);
+                    if (name) {
+                        return name;
+                    }
+                }
             }
-            return Object.values(node)
-                .flat()
-                .some((child) => child &&
-                typeof child === 'object' &&
-                'type' in child &&
-                child !== node.parent &&
-                hasEagerInject(child));
+            return null;
         }
         return {
             [`${utils_1.Selectors.decoratorDefinition(angularDecoratorsPattern)} > ClassBody`](node) {
@@ -58,12 +83,18 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                     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' });
+                    if (member.type === utils_2.AST_NODE_TYPES.PropertyDefinition) {
+                        const functionName = findEagerInjectName(member.value);
+                        if (functionName) {
+                            if (seenNonInject) {
+                                context.report({
+                                    node: member,
+                                    messageId: 'injectAtTop',
+                                    data: { functionName },
+                                });
+                            }
+                            continue;
                         }
-                        continue;
                     }
                     seenNonInject = true;
                 }
@@ -72,5 +103,5 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
     },
 });
 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.",
+    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. Codebases often wrap inject() in their own helpers, for example an injectTranslations() function that injects a translation service and derives a scoped accessor from it; such a helper has exactly the same ordering constraint, so it can be declared through the additionalInjectFunctions option to be treated like inject() itself.",
 };

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

@@ -15,8 +15,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noAsyncLifecycleMethod: 'Angular Lifecycle method should not be async',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const angularDecoratorsPattern = (0, utils_1.toPattern)([
             'Component',

package/dist/rules/no-attribute-decorator.js

@@ -14,8 +14,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noAttributeDecorator: '@Attribute can only obtain a single value and is rarely what is required. Use @Input instead to retrieve a stream of values.',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             'ClassDeclaration MethodDefinition[key.name="constructor"] Decorator[expression.callee.name="Attribute"]'(node) {

package/dist/rules/no-developer-preview.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noDeveloperPreview: '`{{name}}` is in developer preview',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const services = (0, eslint_utils_1.getParserServices)(context);
         const checker = services.program.getTypeChecker();

package/dist/rules/no-duplicates-in-metadata-arrays.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noDuplicatesInMetadataArrays: 'Entry is duplicated in metadata array',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const selectors = [
             // https://angular.dev/api/core/NgModule

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

@@ -18,8 +18,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             noEmptyLifecycleMethod: 'Lifecycle methods should not be empty',
             suggestRemoveLifecycleMethod: 'Remove lifecycle method',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const sourceCode = context.sourceCode;
         const angularDecoratorsPattern = (0, utils_1.toPattern)([

package/dist/rules/no-experimental.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noExperimental: '`{{name}}` is experimental',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const services = (0, eslint_utils_1.getParserServices)(context);
         const checker = services.program.getTypeChecker();

package/dist/rules/no-forward-ref.js

@@ -15,8 +15,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noForwardRef: `Avoid using \`${exports.FORWARD_REF}\``,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [`CallExpression[callee.type="Identifier"][callee.name="${exports.FORWARD_REF}"]`](node) {

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;AAwMH,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;AAiNH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}

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

@@ -18,8 +18,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noImplicitTakeUntilDestroyed: `\`takeUntilDestroyed()\` must be called with an explicit \`DestroyRef\` parameter when used outside of an injection context. See more at ${DEPENDENCY_INJECTION_CONTEXT} and ${RXJS_INTEROP_LINK}`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             CallExpression(node) {
@@ -89,16 +89,26 @@ function isMethodCalledFromInjectionContext(method, classDeclaration) {
         return false;
     }
     const isPrivateField = method.key.type === utils_2.AST_NODE_TYPES.PrivateIdentifier;
+    let isCalledFromInjectionContext = false;
     for (const member of classDeclaration.body.body) {
-        if (!isConstructorMethod(member) &&
-            !utils_1.ASTUtils.isPropertyDefinition(member)) {
+        // Ignore recursive calls from the method to itself
+        if (member === method) {
             continue;
         }
-        if (containsCallToMethod(member, methodName, isPrivateField)) {
-            return true;
+        if (!containsCallToMethod(member, methodName, isPrivateField)) {
+            continue;
+        }
+        if (isConstructorMethod(member) || utils_1.ASTUtils.isPropertyDefinition(member)) {
+            isCalledFromInjectionContext = true;
+        }
+        else {
+            // The method is also called from somewhere that is not an injection
+            // context (e.g. a lifecycle hook or a regular method), so we cannot
+            // assume that `takeUntilDestroyed()` will always run within one.
+            return false;
         }
     }
-    return false;
+    return isCalledFromInjectionContext;
 }
 function isASTNode(value) {
     return (value !== null &&

package/dist/rules/no-input-prefix.js

@@ -29,8 +29,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noInputPrefix: 'Input bindings, including aliases, should not be named, nor prefixed by {{prefixes}}',
         },
+        defaultOptions: [{ prefixes: [] }],
     },
-    defaultOptions: [{ prefixes: [] }],
     create(context, [{ prefixes }]) {
         return {
             [utils_1.Selectors.INPUT_PROPERTY_OR_SETTER](node) {

package/dist/rules/no-input-rename.js

@@ -37,8 +37,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             suggestRemoveAliasName: 'Remove alias name',
             suggestReplaceOriginalNameWithAliasName: 'Remove alias name and use it as the original name',
         },
+        defaultOptions: [{ allowedNames: [] }],
     },
-    defaultOptions: [{ allowedNames: [] }],
     create(context, [{ allowedNames = [] }]) {
         let selectors = new Set();
         const ariaAttributeKeys = (0, utils_1.getAriaAttributeKeys)();

package/dist/rules/no-inputs-metadata-property.js

@@ -18,8 +18,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noInputsMetadataProperty: `Use \`@Input\` rather than the \`${METADATA_PROPERTY_NAME}\` metadata property`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [`${utils_1.Selectors.COMPONENT_OR_DIRECTIVE_CLASS_DECORATOR} ${utils_1.Selectors.metadataProperty(METADATA_PROPERTY_NAME)}`](node) {

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

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noLifecycleCall: 'Avoid explicit calls to lifecycle methods',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const angularLifeCycleMethodsPattern = (0, utils_1.toPattern)([
             ...utils_1.ASTUtils.ANGULAR_LIFECYCLE_METHODS,

package/dist/rules/no-output-native.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noOutputNative: 'Output bindings, including aliases, should not be named as standard DOM events',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const nativeEventNames = (0, utils_1.getNativeEventNames)();
         const selectors = [

package/dist/rules/no-output-on-prefix.js

@@ -17,8 +17,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noOutputOnPrefix: `Output bindings, including aliases, should not be named "on", nor prefixed with it (${STYLE_GUIDE_LINK})`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const outputOnPattern = /^on(([^a-z])|(?=$))/;
         const selectors = [

package/dist/rules/no-output-rename.js

@@ -22,8 +22,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             suggestRemoveAliasName: 'Remove alias name',
             suggestReplaceOriginalNameWithAliasName: 'Remove alias name and use it as the original name',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         let selectors = new Set();
         return {

package/dist/rules/no-outputs-metadata-property.js

@@ -18,8 +18,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noOutputsMetadataProperty: `Use \`@Output\` rather than the \`${METADATA_PROPERTY_NAME}\` metadata property`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [`${utils_1.Selectors.COMPONENT_OR_DIRECTIVE_CLASS_DECORATOR} ${utils_1.Selectors.metadataProperty(METADATA_PROPERTY_NAME)}`](node) {

package/dist/rules/no-pipe-impure.js

@@ -17,8 +17,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             noPipeImpure: 'Impure pipes should be avoided because they are invoked on each change-detection cycle',
             suggestRemovePipeImpure: 'Remove `pure` property',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const sourceCode = context.sourceCode;
         return {

package/dist/rules/no-queries-metadata-property.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noQueriesMetadataProperty: `Use @${utils_1.ASTUtils.AngularInnerClassDecorators.Output} rather than the \`${METADATA_PROPERTY_NAME}\` metadata property`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [utils_1.Selectors.COMPONENT_OR_DIRECTIVE_CLASS_DECORATOR](node) {

package/dist/rules/no-uncalled-signals.js

@@ -33,8 +33,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             noUncalledSignals: 'Doing logic operations on signals will give unexpected results, you probably want to invoke the signal to get its value',
             suggestCallSignal: 'Call this signal to get its value.',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const services = utils_1.ESLintUtils.getParserServices(context);
         function checkForUncalledSignal(node) {

package/dist/rules/pipe-prefix.js

@@ -30,12 +30,12 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             pipePrefix: '@Pipes should be prefixed with {{prefixes}}',
             selectorAfterPrefixFailure: '@Pipes should have a selector after the {{prefixes}} prefix',
         },
+        defaultOptions: [
+            {
+                prefixes: [],
+            },
+        ],
     },
-    defaultOptions: [
-        {
-            prefixes: [],
-        },
-    ],
     create(context, [{ prefixes }]) {
         function checkValidOption(prefixes) {
             return Array.isArray(prefixes) && prefixes.length > 0;

package/dist/rules/prefer-host-metadata-property.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             preferHostMetadataPropertyForBinding: 'Prefer using the `host` metadata property in the `@Component` decorator for host bindings instead of the `@HostBinding` decorator.',
             preferHostMetadataPropertyForListener: 'Prefer using the `host` metadata property in the `@Component` decorator for host listeners instead of the `@HostListener` decorator.',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [utils_1.Selectors.HOST_BINDING_DECORATOR]: (node) => {

package/dist/rules/prefer-inject.js

@@ -17,8 +17,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             preferInject: "Prefer using the inject() function over constructor parameter injection. Use Angular's migration schematic to automatically refactor: ng generate @angular/core:inject",
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const angularDecoratorsPattern = (0, utils_1.toPattern)([
             'Component',

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

@@ -35,8 +35,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             suggestRemoveChangeDetection: `Remove \`${METADATA_PROPERTY_NAME}\` to use the default (\`${STRATEGY_ON_PUSH}\`)`,
             redundantOnPushComponentChangeDetection: `\`${METADATA_PROPERTY_NAME}: ${STRATEGY_ON_PUSH}\` is redundant because \`${STRATEGY_ON_PUSH}\` is the default change detection strategy`,
         },
+        defaultOptions: [DEFAULT_OPTIONS],
     },
-    defaultOptions: [DEFAULT_OPTIONS],
     create(context, [{ allowExplicitOnPush }]) {
         const sourceCode = context.sourceCode;
         const changeDetectionMetadataProperty = utils_1.Selectors.metadataProperty(METADATA_PROPERTY_NAME);

package/dist/rules/prefer-output-emitter-ref.js

@@ -15,8 +15,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             preferOutputEmitterRef: 'Use `OutputEmitterRef` via `output()` for Component and Directive outputs rather than the legacy `@Output()` decorator',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [utils_1.Selectors.OUTPUT_DECORATOR]: (node) => {