@angular-eslint/eslint-plugin 21.1.1-alpha.3 → 21.1.1-alpha.5

package/README.md

@@ -26,6 +26,7 @@ Please see https://github.com/angular-eslint/angular-eslint for full usage instr
 | [`no-attribute-decorator`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-attribute-decorator.md) | The @Attribute decorator is used to obtain a single value for an attribute. This is a much less common use case than getting a stream of values (using @Input), so the @Attribute decorator is often mistakenly used when @Input is intended. This rule disallows the usage of @Attribute decorator entirely to prevent these mistakes. |  |  |  |
 | [`no-developer-preview`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-developer-preview.md) | Disallow using code which is marked as developer preview |  |  |  |
 | [`no-experimental`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-experimental.md) | Disallow using code which is marked as experimental |  |  |  |
+| [`no-implicit-take-until-destroyed`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-implicit-take-until-destroyed.md) | Ensures that `takeUntilDestroyed()` is called with an explicit `DestroyRef` when used outside of an injection context |  |  |  |
 | [`require-lifecycle-on-prototype`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/require-lifecycle-on-prototype.md) | Ensures that lifecycle methods are defined on the object's prototype instead of on an instance. |  |  |  |
 | [`sort-lifecycle-methods`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/sort-lifecycle-methods.md) | Ensures that lifecycle methods are declared in order of execution |  |  |  |
 <!-- prettier-ignore-end -->

package/dist/configs/all.json

@@ -17,6 +17,7 @@
     "@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",

package/dist/index.d.ts

@@ -19,6 +19,7 @@ declare const _default: {
                 "@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;
@@ -83,23 +84,30 @@ declare const _default: {
         "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>;
         "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-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-developer-preview": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noDeveloperPreview", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-duplicates-in-metadata-arrays": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noDuplicatesInMetadataArrays", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-empty-lifecycle-method": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-empty-lifecycle-method").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "no-experimental": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noExperimental", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-forward-ref": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noForwardRef", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "no-implicit-take-until-destroyed": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noImplicitTakeUntilDestroyed", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-input-prefix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noInputPrefix", import("./rules/no-input-prefix").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-input-rename": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-input-rename").MessageIds, import("./rules/no-input-rename").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-inputs-metadata-property": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noInputsMetadataProperty", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-lifecycle-call": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noLifecycleCall", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-        "no-uncalled-signals": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-uncalled-signals").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-output-native": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noOutputNative", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-output-on-prefix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noOutputOnPrefix", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-output-rename": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-output-rename").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-outputs-metadata-property": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noOutputsMetadataProperty", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-pipe-impure": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-pipe-impure").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-queries-metadata-property": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noQueriesMetadataProperty", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "no-uncalled-signals": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-uncalled-signals").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "pipe-prefix": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/pipe-prefix").MessageIds, import("./rules/pipe-prefix").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "prefer-host-metadata-property": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/prefer-host-metadata-property").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "prefer-inject": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferInject", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "prefer-on-push-component-change-detection": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/prefer-on-push-component-change-detection").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "prefer-output-emitter-ref": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferOutputEmitterRef", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "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>;
+        "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-signals": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/prefer-signals").MessageIds, [{
             preferReadonlySignalProperties: boolean;
             preferInputSignals: boolean;
@@ -108,10 +116,6 @@ declare const _default: {
             additionalSignalCreationFunctions: string[];
         }], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "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>;
-        "prefer-inject": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferInject", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-        "prefer-output-emitter-ref": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferOutputEmitterRef", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-        "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>;
-        "prefer-signal-model": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferSignalModel", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "relative-url-prefix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"relativeUrlPrefix", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "require-lifecycle-on-prototype": import("@typescript-eslint/utils/ts-eslint").RuleModule<"defineOnPrototype", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "require-localize-metadata": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/require-localize-metadata").MessageIds, import("./rules/require-localize-metadata").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
@@ -123,8 +127,6 @@ declare const _default: {
         "use-injectable-provided-in": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/use-injectable-provided-in").MessageIds, import("./rules/use-injectable-provided-in").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "use-lifecycle-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"useLifecycleInterface", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "use-pipe-transform-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"usePipeTransformInterface", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-        "no-experimental": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noExperimental", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-        "no-developer-preview": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noDeveloperPreview", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     };
 };
 export = _default;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiJA,kBAuDE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoJA,kBAwDE"}

package/dist/index.js

@@ -84,6 +84,7 @@ const use_lifecycle_interface_1 = __importStar(require("./rules/use-lifecycle-in
 const use_pipe_transform_interface_1 = __importStar(require("./rules/use-pipe-transform-interface"));
 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"));
 module.exports = {
     configs: {
         all: all_json_1.default,
@@ -101,29 +102,32 @@ module.exports = {
         [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,
+        [no_experimental_1.RULE_NAME]: no_experimental_1.default,
         [no_forward_ref_1.RULE_NAME]: no_forward_ref_1.default,
+        [no_implicit_take_until_destroyed_1.RULE_NAME]: no_implicit_take_until_destroyed_1.default,
         [no_input_prefix_1.RULE_NAME]: no_input_prefix_1.default,
         [no_input_rename_1.RULE_NAME]: no_input_rename_1.default,
         [no_inputs_metadata_property_1.RULE_NAME]: no_inputs_metadata_property_1.default,
         [no_lifecycle_call_1.RULE_NAME]: no_lifecycle_call_1.default,
-        [no_uncalled_signals_1.RULE_NAME]: no_uncalled_signals_1.default,
         [no_output_native_1.RULE_NAME]: no_output_native_1.default,
         [no_output_on_prefix_1.RULE_NAME]: no_output_on_prefix_1.default,
         [no_output_rename_1.RULE_NAME]: no_output_rename_1.default,
         [no_outputs_metadata_property_1.RULE_NAME]: no_outputs_metadata_property_1.default,
         [no_pipe_impure_1.RULE_NAME]: no_pipe_impure_1.default,
         [no_queries_metadata_property_1.RULE_NAME]: no_queries_metadata_property_1.default,
+        [no_uncalled_signals_1.RULE_NAME]: no_uncalled_signals_1.default,
         [pipe_prefix_1.RULE_NAME]: pipe_prefix_1.default,
         [prefer_host_metadata_property_1.RULE_NAME]: prefer_host_metadata_property_1.default,
-        [prefer_on_push_component_change_detection_1.RULE_NAME]: prefer_on_push_component_change_detection_1.default,
-        [prefer_signals_1.RULE_NAME]: prefer_signals_1.default,
-        [prefer_standalone_1.RULE_NAME]: prefer_standalone_1.default,
         [prefer_inject_1.RULE_NAME]: prefer_inject_1.default,
+        [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_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,
         [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,
@@ -135,7 +139,5 @@ module.exports = {
         [use_injectable_provided_in_1.RULE_NAME]: use_injectable_provided_in_1.default,
         [use_lifecycle_interface_1.RULE_NAME]: use_lifecycle_interface_1.default,
         [use_pipe_transform_interface_1.RULE_NAME]: use_pipe_transform_interface_1.default,
-        [no_experimental_1.RULE_NAME]: no_experimental_1.default,
-        [no_developer_preview_1.RULE_NAME]: no_developer_preview_1.default,
     },
 };

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

@@ -0,0 +1,9 @@
+export type Options = [];
+export type MessageIds = 'noImplicitTakeUntilDestroyed';
+export declare const RULE_NAME = "no-implicit-take-until-destroyed";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noImplicitTakeUntilDestroyed", [], import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=no-implicit-take-until-destroyed.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,83 @@
+"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-implicit-take-until-destroyed';
+const RXJS_INTEROP_LINK = 'https://angular.dev/ecosystem/rxjs-interop/take-until-destroyed';
+const DEPENDENCY_INJECTION_CONTEXT = 'https://angular.dev/guide/di/dependency-injection-context';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: `Ensures that \`takeUntilDestroyed()\` is called with an explicit \`DestroyRef\` when used outside of an injection context`,
+        },
+        schema: [],
+        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: [],
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== utils_2.AST_NODE_TYPES.Identifier ||
+                    node.callee.name !== 'takeUntilDestroyed' ||
+                    node.arguments.length > 0 ||
+                    isInInjectionContext(node)) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'noImplicitTakeUntilDestroyed',
+                });
+            },
+        };
+    },
+});
+function isInInjectionContext(node) {
+    let current = node;
+    while (current) {
+        if (isInFactoryFunction(current)) {
+            return true;
+        }
+        if (utils_1.ASTUtils.isPropertyDefinition(current) ||
+            isConstructorMethod(current)) {
+            const classDeclaration = utils_1.ASTUtils.getNearestNodeFrom(current, utils_1.ASTUtils.isClassDeclaration);
+            if (!classDeclaration) {
+                current = current.parent;
+                continue;
+            }
+            const decorator = utils_1.ASTUtils.getAngularClassDecorator(classDeclaration);
+            if (decorator && decorator !== 'NgModule') {
+                return true;
+            }
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function isConstructorMethod(node) {
+    return (node.type === utils_2.AST_NODE_TYPES.MethodDefinition && node.kind === 'constructor');
+}
+function isInFactoryFunction(node) {
+    if (node.type !== utils_2.AST_NODE_TYPES.ArrowFunctionExpression &&
+        node.type !== utils_2.AST_NODE_TYPES.FunctionExpression) {
+        return false;
+    }
+    const parent = node.parent;
+    if (!utils_1.ASTUtils.isProperty(parent)) {
+        return false;
+    }
+    const key = parent.key;
+    if (key.type === utils_2.AST_NODE_TYPES.Identifier &&
+        ['factory', 'useFactory'].includes(key.name)) {
+        return true;
+    }
+    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)\`.`,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/eslint-plugin",
-  "version": "21.1.1-alpha.3",
+  "version": "21.1.1-alpha.5",
   "description": "ESLint plugin for Angular applications, following https://angular.dev/style-guide",
   "license": "MIT",
   "main": "dist/index.js",
@@ -19,11 +19,11 @@
   ],
   "dependencies": {
     "ts-api-utils": "^2.1.0",
-    "@angular-eslint/bundled-angular-compiler": "21.1.1-alpha.3",
-    "@angular-eslint/utils": "21.1.1-alpha.3"
+    "@angular-eslint/bundled-angular-compiler": "21.1.1-alpha.5",
+    "@angular-eslint/utils": "21.1.1-alpha.5"
   },
   "devDependencies": {
-    "@angular-eslint/test-utils": "21.1.1-alpha.3"
+    "@angular-eslint/test-utils": "21.1.1-alpha.5"
   },
   "peerDependencies": {
     "@typescript-eslint/utils": "^7.11.0 || ^8.0.0",