@ethlete/eslint-plugin 1.0.0-next.23 → 1.0.0-next.24

package/src/rules/prefer-concise-angular-host-directives.js

@@ -1,29 +1,16 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 /** @typedef {'Component' | 'Directive'} TDecoratorName */
 /** @typedef {import('estree').Property & { range: [number, number] }} TPropertyNode */
 /** @typedef {import('estree').ArrayExpression & { elements: Array<import('estree').Expression | import('estree').SpreadElement | null> }} TArrayExpressionNode */
 /** @typedef {import('estree').ObjectExpression & { properties: Array<TPropertyNode | import('estree').SpreadElement> }} TObjectExpressionNode */
-/** @typedef {{ hasComma: boolean; originalIndex: number; orderIndex: number; property: TPropertyNode; segmentText: string }} TPropertyEntry */
+/** @typedef {{ bodyText: string; hasComma: boolean; originalIndex: number; orderIndex: number; property: TPropertyNode; trailingText: string }} TPropertyEntry */
 
 const HOST_DIRECTIVE_PROPERTY_ORDER = ['directive', 'inputs', 'outputs'];
 
-/**
- * @param {import('eslint').Rule.Node} node
- */
-const getDecoratorName = (node) => {
-  const decorator = /** @type {any} */ (node);
-  if (decorator.type !== 'Decorator') return null;
-
-  const expression = decorator.expression;
-  if (expression.type === 'CallExpression') {
-    return expression.callee.type === 'Identifier' ? expression.callee.name : null;
-  }
-
-  return expression.type === 'Identifier' ? expression.name : null;
-};
-
 /**
  * @param {import('estree').Property['key']} key
  */
@@ -98,22 +85,24 @@ const buildSortedObjectText = (node, sourceCode) => {
     /** @param {TPropertyNode} property @param {number} originalIndex @returns {TPropertyEntry} */
     (property, originalIndex) => {
       const tokenAfter = sourceCode.getTokenAfter(property);
-      const hasComma = Boolean(tokenAfter && tokenAfter.type === 'Punctuator' && tokenAfter.value === ',');
-      const segmentEnd = hasComma && tokenAfter ? tokenAfter.range[0] : property.range[1];
-      const segmentText = sourceCode.text.slice(segmentStart, segmentEnd);
+      const comma = tokenAfter && tokenAfter.type === 'Punctuator' && tokenAfter.value === ',' ? tokenAfter : null;
+      const bodyText = sourceCode.text.slice(segmentStart, property.range[1]);
+      const afterProperty = comma ?? property;
+      const trailingComment = sourceCode
+        .getCommentsAfter(afterProperty)
+        .filter((comment) => comment.loc?.start.line === property.loc?.end.line)
+        .at(-1);
+      const trailingEnd = trailingComment?.range ? trailingComment.range[1] : afterProperty.range[1];
 
-      if (hasComma && tokenAfter) {
-        segmentStart = tokenAfter.range[1];
-      } else {
-        segmentStart = property.range[1];
-      }
+      segmentStart = trailingEnd;
 
       return {
-        hasComma,
+        bodyText,
+        hasComma: Boolean(comma),
         originalIndex,
         orderIndex: orderIndexMap.get(getPropertyName(property.key)) ?? HOST_DIRECTIVE_PROPERTY_ORDER.length,
         property,
-        segmentText,
+        trailingText: trailingComment ? sourceCode.text.slice(afterProperty.range[1], trailingEnd) : '',
       };
     },
   );
@@ -131,7 +120,10 @@ const buildSortedObjectText = (node, sourceCode) => {
   return (
     '{' +
     sortedEntries
-      .map((entry, index) => `${entry.segmentText}${index < sortedEntries.length - 1 || trailingComma ? ',' : ''}`)
+      .map(
+        (entry, index) =>
+          `${entry.bodyText}${index < sortedEntries.length - 1 || trailingComma ? ',' : ''}${entry.trailingText}`,
+      )
       .join('') +
     suffix +
     '}'
@@ -182,7 +174,7 @@ const preferConciseAngularHostDirectives = {
 
     return {
       Decorator(node) {
-        const decoratorName = getDecoratorName(node);
+        const decoratorName = getAngularDecoratorName(context.sourceCode, node);
         if (decoratorName !== 'Component' && decoratorName !== 'Directive') return;
 
         const hostDirectives = getHostDirectivesArray(decoratorName, node);
@@ -199,10 +191,12 @@ const preferConciseAngularHostDirectives = {
             const directiveValue = getDirectiveValueNode(config);
             if (!directiveValue) continue;
 
+            const hasComments = sourceCode.getCommentsInside(config).length > 0;
+
             context.report({
               node: config,
               messageId: 'preferShorthand',
-              fix: (fixer) => fixer.replaceText(config, sourceCode.getText(directiveValue)),
+              fix: hasComments ? null : (fixer) => fixer.replaceText(config, sourceCode.getText(directiveValue)),
             });
 
             continue;

package/src/rules/prefer-concise-angular-style-metadata.js

@@ -1,24 +1,11 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 /** @typedef {import('estree').Property} TPropertyNode */
 /** @typedef {import('estree').Expression | import('estree').SpreadElement | null} TArrayElement */
 
-/**
- * @param {import('eslint').Rule.Node} node
- */
-const isComponentDecorator = (node) => {
-  const decorator = /** @type {any} */ (node);
-  if (decorator.type !== 'Decorator') return false;
-
-  const expression = decorator.expression;
-  if (expression.type === 'CallExpression') {
-    return expression.callee.type === 'Identifier' && expression.callee.name === 'Component';
-  }
-
-  return expression.type === 'Identifier' && expression.name === 'Component';
-};
-
 /**
  * @param {import('estree').Property['key']} key
  */
@@ -62,7 +49,7 @@ const preferConciseAngularStyleMetadata = {
     return {
       /** @param {import('eslint').Rule.Node} node */
       Decorator(node) {
-        if (!isComponentDecorator(node)) return;
+        if (getAngularDecoratorName(context.sourceCode, node) !== 'Component') return;
 
         const decorator = /** @type {any} */ (node);
         const expression = decorator.expression;
@@ -71,11 +58,16 @@ const preferConciseAngularStyleMetadata = {
         const metadata = expression.arguments[0];
         if (!metadata || metadata.type !== 'ObjectExpression') return;
 
+        const hasStyleUrl = metadata.properties.some(
+          (/** @type {any} */ property) => property.type === 'Property' && getPropertyName(property.key) === 'styleUrl',
+        );
+
         for (const property of metadata.properties) {
           if (property.type !== 'Property') continue;
 
           const propertyName = getPropertyName(property.key);
           if (propertyName !== 'styleUrls' && propertyName !== 'styles') continue;
+          if (propertyName === 'styleUrls' && hasStyleUrl) continue;
 
           const singleElement = getSingleArrayElement(property);
           if (!singleElement) continue;

package/src/rules/prefer-element-dimensions.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { ANGULAR_CORE, getImportedName } = require('./internals/import-resolution');
+
 /**
  * Prefers signalElementDimensions / signalHostElementDimensions from @ethlete/core
  * over imperatively reading element size properties inside reactive contexts
@@ -46,10 +48,11 @@ const ELEMENT_SIZE_METHODS = new Set(['getBoundingClientRect', 'getClientRects']
 /**
  * Returns the name of the wrapping reactive context ('effect' | 'computed') if
  * the node is inside one, crossing exactly one function boundary.
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {import('eslint').Rule.Node} node
  * @returns {string | null}
  */
-const getReactiveContext = (node) => {
+const getReactiveContext = (sourceCode, node) => {
   let crossedFunctionBoundary = false;
   let current = node.parent;
 
@@ -58,13 +61,9 @@ const getReactiveContext = (node) => {
       crossedFunctionBoundary = true;
     }
 
-    if (
-      crossedFunctionBoundary &&
-      current.type === 'CallExpression' &&
-      current.callee.type === 'Identifier' &&
-      (current.callee.name === 'effect' || current.callee.name === 'computed')
-    ) {
-      return current.callee.name;
+    if (crossedFunctionBoundary && current.type === 'CallExpression') {
+      const calleeName = getImportedName(sourceCode, current.callee, ANGULAR_CORE);
+      if (calleeName === 'effect' || calleeName === 'computed') return calleeName;
     }
 
     current = current.parent;
@@ -95,7 +94,7 @@ const preferElementDimensions = {
         if (node.property.type !== 'Identifier') return;
         if (!ELEMENT_SIZE_PROPS.has(node.property.name)) return;
 
-        const reactiveCtx = getReactiveContext(node);
+        const reactiveCtx = getReactiveContext(context.sourceCode, node);
         if (!reactiveCtx) return;
 
         context.report({
@@ -112,7 +111,7 @@ const preferElementDimensions = {
         if (callee.property.type !== 'Identifier') return;
         if (!ELEMENT_SIZE_METHODS.has(callee.property.name)) return;
 
-        const reactiveCtx = getReactiveContext(node);
+        const reactiveCtx = getReactiveContext(context.sourceCode, node);
         if (!reactiveCtx) return;
 
         context.report({

package/src/rules/prefer-linked-signal.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { isImportedAs } = require('./internals/import-resolution');
+
 /**
  * Prefer linkedSignal over setting a signal inside an effect().
  *
@@ -44,9 +46,10 @@
  *    effect is performing side effects alongside the signal write, so they are
  *    not flagged either.
  *
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {import('eslint').Rule.Node} node The `.set()` CallExpression node
  */
-const isPureSetInDirectEffectCallback = (node) => {
+const isPureSetInDirectEffectCallback = (sourceCode, node) => {
   // Find the immediate enclosing function (cross exactly one boundary).
   let current = node.parent;
   let immediateFunction = null;
@@ -66,8 +69,7 @@ const isPureSetInDirectEffectCallback = (node) => {
   if (
     !funcParent ||
     funcParent.type !== 'CallExpression' ||
-    funcParent.callee.type !== 'Identifier' ||
-    funcParent.callee.name !== 'effect' ||
+    !isImportedAs(sourceCode, funcParent.callee, 'effect') ||
     funcParent.arguments[0] !== immediateFunction
   ) {
     return false;
@@ -112,7 +114,8 @@ const preferLinkedSignal = {
           callee.type === 'MemberExpression' &&
           callee.property.type === 'Identifier' &&
           callee.property.name === 'set' &&
-          isPureSetInDirectEffectCallback(node)
+          node.arguments.length === 1 &&
+          isPureSetInDirectEffectCallback(context.sourceCode, node)
         ) {
           context.report({ node, messageId: 'preferLinkedSignal' });
         }

package/src/rules/prefer-match-media.js

@@ -37,6 +37,10 @@
  *   // … etc. All from @ethlete/core.
  */
 
+const { MODULE_REFERENCE_SELECTOR, getModuleReference, isImportedAs } = require('./internals/import-resolution');
+
+const CDK_LAYOUT = '@angular/cdk/layout';
+
 /** @type {import('eslint').Rule.RuleModule} */
 const preferMatchMedia = {
   meta: {
@@ -72,25 +76,17 @@ const preferMatchMedia = {
 
         // ── inject(BreakpointObserver) ────────────────────────────────────────
         if (
-          callee.type === 'Identifier' &&
-          callee.name === 'inject' &&
-          node.arguments[0]?.type === 'Identifier' &&
-          node.arguments[0].name === 'BreakpointObserver'
+          isImportedAs(context.sourceCode, callee, 'inject') &&
+          isImportedAs(context.sourceCode, node.arguments[0], 'BreakpointObserver', CDK_LAYOUT)
         ) {
           context.report({ node, messageId: 'noBreakpointObserver' });
         }
       },
 
-      ImportDeclaration(node) {
-        // ── import { BreakpointObserver } from '@angular/cdk/layout' ─────────
-        if (node.source.value !== '@angular/cdk/layout') return;
-        const hasBreakpointObserver = node.specifiers.some(
-          (s) =>
-            s.type === 'ImportSpecifier' &&
-            s.imported.type === 'Identifier' &&
-            s.imported.name === 'BreakpointObserver',
-        );
-        if (hasBreakpointObserver) {
+      [MODULE_REFERENCE_SELECTOR](node) {
+        const reference = getModuleReference(node);
+        if (reference?.source !== CDK_LAYOUT) return;
+        if (reference.named.some((entry) => entry.name === 'BreakpointObserver')) {
           context.report({ node, messageId: 'noBreakpointObserver' });
         }
       },

package/src/rules/prefer-present-tense-output.js

@@ -72,7 +72,7 @@ const rule = {
   create(context) {
     return {
       PropertyDefinition(node) {
-        const io = getReactiveIo(node);
+        const io = getReactiveIo(context.sourceCode, node);
         if (!io || io.kind !== 'output') return;
 
         const word = lastWord(io.name);

package/src/rules/prefer-rxjs-timer.js

@@ -19,6 +19,8 @@
  *   fromEvent(element, 'click').pipe(takeUntilDestroyed()).subscribe(handler);
  */
 
+const { isGlobalReference } = require('./internals/import-resolution');
+
 /** @type {import('eslint').Rule.RuleModule} */
 const preferRxjsTimer = {
   meta: {
@@ -47,7 +49,7 @@ const preferRxjsTimer = {
         const { callee } = node;
 
         // ── Global timer calls ────────────────────────────────────────────────
-        if (callee.type === 'Identifier') {
+        if (isGlobalReference(context.sourceCode, callee)) {
           const { name } = callee;
           if (name === 'setTimeout') {
             context.report({ node, messageId: 'preferTimer' });

package/src/rules/require-dollar-suffix.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getImportedName } = require('./internals/import-resolution');
+
 /**
  * Requires observable variables and class properties to be suffixed with `$`.
  *
@@ -45,9 +47,10 @@ const RXJS_SUBJECT_CTORS = new Set(['Subject', 'BehaviorSubject', 'ReplaySubject
 
 /**
  * Returns true if the expression looks like an Observable.
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} node
  */
-const isObservableInit = (node) => {
+const isObservableInit = (sourceCode, node) => {
   if (!node) return false;
 
   // someObs.pipe(...)
@@ -61,12 +64,12 @@ const isObservableInit = (node) => {
   }
 
   // from(...), of(...), interval(...), etc.
-  if (node.type === 'CallExpression' && node.callee.type === 'Identifier' && RXJS_CREATORS.has(node.callee.name)) {
+  if (node.type === 'CallExpression' && RXJS_CREATORS.has(getImportedName(sourceCode, node.callee, 'rxjs') ?? '')) {
     return true;
   }
 
   // new Subject(), new BehaviorSubject(...), etc.
-  if (node.type === 'NewExpression' && node.callee.type === 'Identifier' && RXJS_SUBJECT_CTORS.has(node.callee.name)) {
+  if (node.type === 'NewExpression' && RXJS_SUBJECT_CTORS.has(getImportedName(sourceCode, node.callee, 'rxjs') ?? '')) {
     return true;
   }
 
@@ -92,7 +95,7 @@ const rule = {
      * @param {any} initNode
      */
     const checkBinding = (name, reportNode, initNode) => {
-      if (!isObservableInit(initNode)) return;
+      if (!isObservableInit(context.sourceCode, initNode)) return;
       if (name.endsWith('$')) return;
 
       context.report({

package/src/rules/require-on-push-change-detection.js

@@ -1,6 +1,14 @@
 // @ts-check
 'use strict';
 
+const {
+  ANGULAR_CORE,
+  getAngularDecoratorName,
+  getImportLocalName,
+  isImportedAs,
+  resolveIdentifier,
+} = require('./internals/import-resolution');
+
 const COMPONENT_ORDER = ['selector', 'template', 'styleUrl', 'encapsulation', 'changeDetection'];
 
 // OnPush became the default change detection strategy in Angular 22, so from
@@ -187,7 +195,7 @@ const getChangeDetectionInsertionTarget = (metadata) => {
  * @param {any} metadata
  */
 const buildMetadataFix = (sourceCode, metadata) => {
-  const changeDetectionText = 'changeDetection: ChangeDetectionStrategy.OnPush';
+  const changeDetectionText = `changeDetection: ${getImportLocalName(sourceCode, ANGULAR_CORE, 'ChangeDetectionStrategy') ?? 'ChangeDetectionStrategy'}.OnPush`;
   const properties = metadata.properties;
   const insertionTarget = getChangeDetectionInsertionTarget(metadata);
   const isMultiline = Boolean(metadata.loc && metadata.loc.start.line !== metadata.loc.end.line);
@@ -236,6 +244,10 @@ const buildMetadataFix = (sourceCode, metadata) => {
  * @param {any} valueNode
  */
 const buildFix = (sourceCode, metadata, valueNode) => {
+  const valueFix = valueNode && ((fixer) => fixer.replaceText(valueNode.property, 'OnPush'));
+  if (valueNode && valueNode.object.type !== 'Identifier') return valueFix;
+  if (valueNode && resolveIdentifier(sourceCode, valueNode.object)?.source) return valueFix;
+
   const fixes = [];
   const angularCoreImport = findAngularCoreImport(sourceCode);
   const importFix = angularCoreImport
@@ -244,12 +256,8 @@ const buildFix = (sourceCode, metadata, valueNode) => {
 
   if (importFix) fixes.push(importFix);
 
-  if (valueNode) {
-    fixes.push((fixer) => fixer.replaceText(valueNode, 'ChangeDetectionStrategy.OnPush'));
-  } else {
-    const metadataFix = buildMetadataFix(sourceCode, metadata);
-    if (metadataFix) fixes.push(metadataFix);
-  }
+  const metadataFix = valueFix ?? buildMetadataFix(sourceCode, metadata);
+  if (metadataFix) fixes.push(metadataFix);
 
   return (fixer) => fixes.map((applyFix) => applyFix(fixer));
 };
@@ -278,24 +286,9 @@ const requireOnPushChangeDetection = {
 
     const sourceCode = context.sourceCode;
 
-    /**
-     * @param {import('eslint').Rule.Node} node
-     */
-    const isComponentDecorator = (node) => {
-      const decorator = /** @type {any} */ (node);
-      if (decorator.type !== 'Decorator') return false;
-
-      const expression = decorator.expression;
-      if (expression.type === 'CallExpression') {
-        return expression.callee.type === 'Identifier' && expression.callee.name === 'Component';
-      }
-
-      return expression.type === 'Identifier' && expression.name === 'Component';
-    };
-
     return {
       Decorator(node) {
-        if (!isComponentDecorator(node)) return;
+        if (getAngularDecoratorName(sourceCode, node) !== 'Component') return;
 
         const decorator = /** @type {any} */ (node);
         const expression = decorator.expression;
@@ -320,8 +313,7 @@ const requireOnPushChangeDetection = {
         const value = changeDetectionProp.value;
         if (
           value.type === 'MemberExpression' &&
-          value.object.type === 'Identifier' &&
-          value.object.name === 'ChangeDetectionStrategy' &&
+          isImportedAs(sourceCode, value.object, 'ChangeDetectionStrategy') &&
           value.property.type === 'Identifier' &&
           value.property.name !== 'OnPush'
         ) {

package/src/rules/require-view-encapsulation-none.js

@@ -1,6 +1,14 @@
 // @ts-check
 'use strict';
 
+const {
+  ANGULAR_CORE,
+  getAngularDecoratorName,
+  getImportLocalName,
+  isImportedAs,
+  resolveIdentifier,
+} = require('./internals/import-resolution');
+
 const COMPONENT_ORDER = ['selector', 'template', 'styleUrl', 'encapsulation', 'changeDetection'];
 
 /**
@@ -141,7 +149,7 @@ const getEncapsulationInsertionTarget = (metadata) => {
  * @param {any} metadata
  */
 const buildMetadataFix = (sourceCode, metadata) => {
-  const encText = 'encapsulation: ViewEncapsulation.None';
+  const encText = `encapsulation: ${getImportLocalName(sourceCode, ANGULAR_CORE, 'ViewEncapsulation') ?? 'ViewEncapsulation'}.None`;
   const properties = metadata.properties;
   const insertionTarget = getEncapsulationInsertionTarget(metadata);
   const isMultiline = Boolean(metadata.loc && metadata.loc.start.line !== metadata.loc.end.line);
@@ -189,6 +197,10 @@ const buildMetadataFix = (sourceCode, metadata) => {
  * @param {any} valueNode
  */
 const buildFix = (sourceCode, metadata, valueNode) => {
+  const valueFix = valueNode && ((fixer) => fixer.replaceText(valueNode.property, 'None'));
+  if (valueNode && valueNode.object.type !== 'Identifier') return valueFix;
+  if (valueNode && resolveIdentifier(sourceCode, valueNode.object)?.source) return valueFix;
+
   const fixes = [];
   const angularCoreImport = findAngularCoreImport(sourceCode);
   const importFix = angularCoreImport
@@ -197,12 +209,8 @@ const buildFix = (sourceCode, metadata, valueNode) => {
 
   if (importFix) fixes.push(importFix);
 
-  if (valueNode) {
-    fixes.push((fixer) => fixer.replaceText(valueNode, 'ViewEncapsulation.None'));
-  } else {
-    const metadataFix = buildMetadataFix(sourceCode, metadata);
-    if (metadataFix) fixes.push(metadataFix);
-  }
+  const metadataFix = valueFix ?? buildMetadataFix(sourceCode, metadata);
+  if (metadataFix) fixes.push(metadataFix);
 
   return (fixer) => fixes.map((applyFix) => applyFix(fixer));
 };
@@ -224,24 +232,9 @@ const requireViewEncapsulationNone = {
   create(context) {
     const sourceCode = context.sourceCode;
 
-    /**
-     * @param {import('eslint').Rule.Node} node
-     */
-    const isComponentDecorator = (node) => {
-      const decorator = /** @type {any} */ (node);
-      if (decorator.type !== 'Decorator') return false;
-
-      const expression = decorator.expression;
-      if (expression.type === 'CallExpression') {
-        return expression.callee.type === 'Identifier' && expression.callee.name === 'Component';
-      }
-
-      return expression.type === 'Identifier' && expression.name === 'Component';
-    };
-
     return {
       Decorator(node) {
-        if (!isComponentDecorator(node)) return;
+        if (getAngularDecoratorName(sourceCode, node) !== 'Component') return;
 
         const decorator = /** @type {any} */ (node);
         const expression = decorator.expression;
@@ -266,8 +259,7 @@ const requireViewEncapsulationNone = {
         const value = encProp.value;
         if (
           value.type === 'MemberExpression' &&
-          value.object.type === 'Identifier' &&
-          value.object.name === 'ViewEncapsulation' &&
+          isImportedAs(sourceCode, value.object, 'ViewEncapsulation') &&
           value.property.type === 'Identifier' &&
           value.property.name !== 'None'
         ) {

package/src/rules/take-until-destroyed-last.js

@@ -0,0 +1,64 @@
+// @ts-check
+'use strict';
+
+const { isImportedAs } = require('./internals/import-resolution');
+
+/**
+ * Requires takeUntilDestroyed() to be the last operator in a .pipe().
+ *
+ * BAD:
+ *   obs$.pipe(
+ *     takeUntilDestroyed(),
+ *     switchMap(() => fromEvent(el, 'scroll')), // ❌ the inner subscription outlives the component
+ *   ).subscribe();
+ *
+ * GOOD:
+ *   obs$.pipe(
+ *     switchMap(() => fromEvent(el, 'scroll')),
+ *     takeUntilDestroyed(), // ✅ tears down everything above it
+ *   ).subscribe();
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+const takeUntilDestroyedLast = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Require takeUntilDestroyed() to be the last operator in a .pipe().',
+      recommended: true,
+    },
+    messages: {
+      takeUntilDestroyedLast:
+        'takeUntilDestroyed() must be the last operator in the pipe. An operator after it (switchMap, shareReplay, …) can keep the subscription alive after destroy.',
+    },
+    schema: [],
+  },
+  create(context) {
+    /** @param {import('estree').Node} node */
+    const isTakeUntilDestroyedCall = (node) =>
+      node.type === 'CallExpression' &&
+      isImportedAs(context.sourceCode, node.callee, 'takeUntilDestroyed', '@angular/core/rxjs-interop');
+
+    return {
+      CallExpression(node) {
+        const { callee } = node;
+        if (
+          callee.type !== 'MemberExpression' ||
+          callee.property.type !== 'Identifier' ||
+          callee.property.name !== 'pipe'
+        ) {
+          return;
+        }
+
+        const lastIndex = node.arguments.length - 1;
+        node.arguments.forEach((arg, index) => {
+          if (index < lastIndex && isTakeUntilDestroyedCall(arg)) {
+            context.report({ node: arg, messageId: 'takeUntilDestroyedLast' });
+          }
+        });
+      },
+    };
+  },
+};
+
+module.exports = takeUntilDestroyedLast;

package/src/rules/template-member-accessibility.js

@@ -7,15 +7,17 @@ const {
   isReferencedFromTemplateOrHost,
 } = require('./internals/angular-member-visibility');
 const { getImplementedContractMemberNames } = require('./internals/implemented-contract-members');
+const { isImportedAs } = require('./internals/import-resolution');
 const { buildAccessibilityFix } = require('./internals/member-accessibility-fix');
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} node
  */
-const isInjectCall = (node) => {
+const isInjectCall = (sourceCode, node) => {
   if (!node || node.type !== 'PropertyDefinition' || !node.value) return false;
   if (node.value.type !== 'CallExpression') return false;
-  return node.value.callee.type === 'Identifier' && node.value.callee.name === 'inject';
+  return isImportedAs(sourceCode, node.value.callee, 'inject');
 };
 
 /**
@@ -91,11 +93,11 @@ const templateMemberAccessibility = {
      */
     const checkMember = (node) => {
       if (!isSupportedMember(node)) return;
-      if (node.type === 'PropertyDefinition' && isInjectCall(node)) return;
+      if (node.type === 'PropertyDefinition' && isInjectCall(context.sourceCode, node)) return;
 
       const classNode = node.parent && node.parent.type === 'ClassBody' ? node.parent.parent : null;
       if (!classNode || (classNode.type !== 'ClassDeclaration' && classNode.type !== 'ClassExpression')) return;
-      if (!getAngularMetadata(classNode)) return;
+      if (!getAngularMetadata(context.sourceCode, classNode)) return;
 
       const memberName = getMemberName(node);
       if (!memberName) return;
@@ -148,11 +150,11 @@ const templateMemberAccessibility = {
      */
     const checkImplicitPublicMember = (node) => {
       if (!isSupportedMember(node)) return;
-      if (node.type === 'PropertyDefinition' && isInjectCall(node)) return;
+      if (node.type === 'PropertyDefinition' && isInjectCall(context.sourceCode, node)) return;
 
       const classNode = node.parent && node.parent.type === 'ClassBody' ? node.parent.parent : null;
       if (!classNode || (classNode.type !== 'ClassDeclaration' && classNode.type !== 'ClassExpression')) return;
-      if (!getAngularMetadata(classNode)) return;
+      if (!getAngularMetadata(context.sourceCode, classNode)) return;
 
       const memberName = getMemberName(node);
       if (!memberName) return;