@ethlete/eslint-plugin 1.0.0-next.27 → 1.0.0-next.28

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 1.0.0-next.28
+
+### Minor Changes
+
+- The recommended config now also bans functional route guards and resolvers (`canDeactivate` stays allowed), and barrel imports through `'.'`, `'..'` or `./index.js`.
+
+### Patch Changes
+
+- Fix wrong reports and unsafe autofixes in ten rules: `--fix` no longer makes template members `private`, adds `readonly` to template-written fields, widens a return type to `any`, or drops comments.
+
 ## 1.0.0-next.27
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/eslint-plugin",
-  "version": "1.0.0-next.27",
+  "version": "1.0.0-next.28",
   "license": "MIT",
   "type": "commonjs",
   "main": "./src/index.js",

package/src/configs/recommended.js

@@ -157,17 +157,18 @@ const recommendedTs = {
       // No route guards — handle access control inside the component itself
       {
         selector:
-          'TSClassImplements > Identifier.expression[name=/^CanActivate$|^CanDeactivate$|^CanActivateChild$|^CanMatch$|^CanLoad$/]',
+          'TSClassImplements > Identifier.expression[name=/^CanActivate$|^CanDeactivate$|^CanActivateChild$|^CanMatch$|^CanLoad$/], TSTypeReference > Identifier.typeName[name=/^(CanActivate|CanActivateChild|CanMatch)Fn$/], ObjectExpression:has(> Property[key.name=/^(path|component|loadComponent|children|loadChildren)$/]) > Property[key.name=/^(canActivate|canActivateChild|canMatch|canLoad)$/]',
         message: 'No route guards. Handle access control inside the component itself.',
       },
       // No route resolvers — use the query library to fetch data
       {
-        selector: "TSClassImplements > Identifier.expression[name='Resolve']",
+        selector:
+          "TSClassImplements > Identifier.expression[name='Resolve'], TSTypeReference > Identifier.typeName[name='ResolveFn'], ObjectExpression:has(> Property[key.name=/^(path|component|loadComponent|children|loadChildren)$/]) > Property[key.name='resolve']",
         message: 'No route resolvers. Use the query library to fetch data instead.',
       },
       // No barrel imports — import directly from the source file
       {
-        selector: 'ImportDeclaration[source.value=/(^|[/])index$/]',
+        selector: 'ImportDeclaration[source.value=/(^|[/])(index([.][cm]?[jt]s)?|[.]|[.][.])?[/]?$/]',
         message:
           'No barrel imports (index files). Import directly from the source file to avoid breaking lazy loading.',
       },

package/src/rules/class-constant-property.js

@@ -1,6 +1,7 @@
 // @ts-check
 'use strict';
 
+const { getAngularMetadata, isWrittenFromTemplateOrHost } = require('./internals/angular-member-visibility');
 const { getAngularDecoratorName } = require('./internals/import-resolution');
 
 const SCREAMING_CASE_RE = /^[A-Z][A-Z0-9_]*$/;
@@ -327,6 +328,7 @@ const classConstantProperty = {
     return {
       ClassBody(node) {
         const writtenMembers = getWrittenMembers(node);
+        const isAngularClass = getAngularMetadata(context.sourceCode, node.parent) !== null;
 
         for (const member of node.body) {
           if (!isConstantProperty(member)) {
@@ -347,6 +349,11 @@ const classConstantProperty = {
             continue;
           }
 
+          if (isAngularClass && !member.readonly) {
+            if (member.accessibility !== 'private' && member.accessibility !== 'protected') continue;
+            if (isWrittenFromTemplateOrHost(node.parent, memberName, context)) continue;
+          }
+
           if (memberName === 'transform' && hasPipeDecorator(context.sourceCode, node.parent)) {
             continue;
           }

package/src/rules/internals/angular-member-visibility.js

@@ -127,6 +127,115 @@ const getContextFilename = (context) => {
   return filename;
 };
 
+/**
+ * @param {string} memberName
+ */
+const memberNamePattern = (memberName) =>
+  new RegExp(`(?:(?<![\\w$.])|(?<=(?<![\\w$])this\\.)|(?<=\\.\\.\\.))${escapeRegExp(memberName)}(?![\\w$])`, 'u');
+
+const BINDING_ATTRIBUTE_PATTERN =
+  /(?:^|[\s<])(\[\([^)]*\)\]|\[[^\]]*\]|\([^)]*\)|\*[\w-]+|bind-[\w-]+|on-[\w-]+|bindon-[\w-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/gu;
+
+const BLOCK_HEADER_PATTERN = /@(?:else\s+if|[a-zA-Z]+)\s*\(/gu;
+
+const LET_DECLARATION_PATTERN = /@let\s+[\w$]+\s*=([^;]*)/gu;
+
+/**
+ * @param {string} text
+ * @param {number} openIndex
+ */
+const readBalancedParens = (text, openIndex) => {
+  let depth = 0;
+  /** @type {string | null} */
+  let quote = null;
+
+  for (let index = openIndex; index < text.length; index++) {
+    const char = text[index];
+
+    if (quote) {
+      if (char === quote && text[index - 1] !== '\\') quote = null;
+      continue;
+    }
+
+    if (char === '"' || char === "'" || char === '`') quote = char;
+    else if (char === '(') depth++;
+    else if (char === ')' && --depth === 0) return text.slice(openIndex + 1, index);
+  }
+
+  return text.slice(openIndex + 1);
+};
+
+/**
+ * @param {string} template
+ */
+const getInterpolations = (template) => {
+  /** @type {string[]} */
+  const expressions = [];
+  let searchFrom = 0;
+
+  while (true) {
+    const start = template.indexOf('{{', searchFrom);
+    if (start === -1) break;
+
+    let depth = 0;
+    let index = start + 2;
+
+    for (; index < template.length; index++) {
+      if (template[index] === '{') depth++;
+      else if (template[index] === '}') {
+        if (depth > 0) depth--;
+        else if (template[index + 1] === '}') break;
+      }
+    }
+
+    expressions.push(template.slice(start + 2, index));
+    searchFrom = index + 2;
+  }
+
+  return expressions;
+};
+
+/**
+ * @typedef {{ name: string; expression: string }} TemplateBinding
+ */
+
+/**
+ * @param {string} template
+ * @returns {TemplateBinding[]}
+ */
+const getBindingAttributes = (template) =>
+  [...template.matchAll(BINDING_ATTRIBUTE_PATTERN)].map((match) => ({
+    name: match[1] ?? '',
+    expression: match[2] ?? match[3] ?? '',
+  }));
+
+/**
+ * @param {string} template
+ */
+const getTemplateExpressions = (template) => {
+  const expressions = getInterpolations(template);
+
+  for (const binding of getBindingAttributes(template)) {
+    expressions.push(binding.expression);
+  }
+
+  for (const match of template.matchAll(BLOCK_HEADER_PATTERN)) {
+    expressions.push(readBalancedParens(template, (match.index ?? 0) + match[0].length - 1));
+  }
+
+  for (const match of template.matchAll(LET_DECLARATION_PATTERN)) {
+    expressions.push(match[1] ?? '');
+  }
+
+  return expressions;
+};
+
+/**
+ * @param {string} bindingName
+ */
+const isWritingBinding = (bindingName) =>
+  bindingName.startsWith('(') || bindingName.startsWith('[(') || /^(?:on|bindon)-/u.test(bindingName);
+
 /**
  * @param {string} memberName
  * @param {string | null} template
@@ -134,20 +243,23 @@ const getContextFilename = (context) => {
 const templateReferencesMember = (memberName, template) => {
   if (!template) return false;
 
-  const escapedName = escapeRegExp(memberName);
-  const patterns = [
-    new RegExp(`\\{\\{[^{}]*\\b${escapedName}\\b[^{}]*\\}\\}`, 'u'),
-    new RegExp(`@[a-zA-Z]+(?:\\s+if)?\\s*\\([^)]*\\b${escapedName}\\b[^)]*\\)`, 'u'),
-    new RegExp(`@let\\s+[a-zA-Z_$][\\w$]*\\s*=\\s*[^;]*\\b${escapedName}\\b`, 'u'),
-    new RegExp(`\\*[a-zA-Z0-9_\\-]+\\s*=\\s*"[^"]*\\b${escapedName}\\b[^"]*"`, 'u'),
-    new RegExp(`\\*[a-zA-Z0-9_\\-]+\\s*=\\s*'[^']*\\b${escapedName}\\b[^']*'`, 'u'),
-    new RegExp(`\\[[^\\]]+\\]\\s*=\\s*"[^"]*\\b${escapedName}\\b[^"]*"`, 'u'),
-    new RegExp(`\\[[^\\]]+\\]\\s*=\\s*'[^']*\\b${escapedName}\\b[^']*'`, 'u'),
-    new RegExp(`\\([^\\)]+\\)\\s*=\\s*"[^"]*\\b${escapedName}\\b[^"]*"`, 'u'),
-    new RegExp(`\\([^\\)]+\\)\\s*=\\s*'[^']*\\b${escapedName}\\b[^']*'`, 'u'),
-  ];
-
-  return patterns.some((pattern) => pattern.test(template));
+  const pattern = memberNamePattern(memberName);
+
+  return getTemplateExpressions(template).some((expression) => pattern.test(expression));
+};
+
+/**
+ * @param {string} memberName
+ * @param {string | null} template
+ */
+const templateWritesMember = (memberName, template) => {
+  if (!template) return false;
+
+  const pattern = memberNamePattern(memberName);
+
+  return getBindingAttributes(template).some(
+    (binding) => isWritingBinding(binding.name) && pattern.test(binding.expression),
+  );
 };
 
 /**
@@ -183,50 +295,73 @@ const getAngularMetadata = (sourceCode, classNode) => {
 const textReferencesMember = (memberName, text) => {
   if (!text) return false;
 
-  const pattern = new RegExp(`\\b${escapeRegExp(memberName)}\\b`, 'u');
-  return pattern.test(text);
+  return memberNamePattern(memberName).test(text);
 };
 
 /**
- * @param {string} memberName
  * @param {any} metadata
  * @param {import('eslint').Rule.RuleContext} context
  */
-const isReferencedFromTemplateOrHostMetadata = (memberName, metadata, context) => {
-  const templateProperty = getMetadataProperty(metadata, 'template');
-  if (templateProperty && templateReferencesMember(memberName, getStringValue(templateProperty.value))) {
-    return true;
-  }
+const getTemplateTexts = (metadata, context) => {
+  /** @type {string[]} */
+  const templates = [];
 
-  const templateUrlProperty = getMetadataProperty(metadata, 'templateUrl');
-  if (templateUrlProperty) {
-    const templateUrl = getStringValue(templateUrlProperty.value);
-    const filename = getContextFilename(context);
+  const inlineTemplate = getStringValue(getMetadataProperty(metadata, 'template')?.value);
+  if (inlineTemplate) templates.push(inlineTemplate);
 
-    if (templateUrl && filename) {
-      const templatePath = path.resolve(path.dirname(filename), templateUrl);
-      const templateText = readTemplateText(context.sourceCode, templatePath);
-      if (templateReferencesMember(memberName, templateText)) {
-        return true;
-      }
-    }
+  const templateUrl = getStringValue(getMetadataProperty(metadata, 'templateUrl')?.value);
+  const filename = getContextFilename(context);
+
+  if (templateUrl && filename) {
+    const templateText = readTemplateText(context.sourceCode, path.resolve(path.dirname(filename), templateUrl));
+    if (templateText) templates.push(templateText);
   }
 
+  return templates;
+};
+
+/**
+ * @param {any} metadata
+ */
+const getHostBindings = (metadata) => {
   const hostProperty = getMetadataProperty(metadata, 'host');
-  if (hostProperty && hostProperty.value.type === 'ObjectExpression') {
-    for (const property of hostProperty.value.properties) {
-      if (!property || property.type !== 'Property') continue;
-      if (!isDynamicHostBindingKey(getPropertyKeyName(property))) continue;
+  if (!hostProperty || hostProperty.value.type !== 'ObjectExpression') return [];
 
-      if (textReferencesMember(memberName, getStringValue(property.value))) {
-        return true;
-      }
-    }
+  /** @type {TemplateBinding[]} */
+  const bindings = [];
+
+  for (const property of hostProperty.value.properties) {
+    if (!property || property.type !== 'Property') continue;
+
+    const keyName = getPropertyKeyName(property);
+    if (!isDynamicHostBindingKey(keyName)) continue;
+
+    bindings.push({ name: keyName ?? '', expression: getStringValue(property.value) ?? '' });
   }
 
-  return false;
+  return bindings;
 };
 
+/**
+ * @param {string} memberName
+ * @param {any} metadata
+ * @param {import('eslint').Rule.RuleContext} context
+ */
+const isReferencedFromTemplateOrHostMetadata = (memberName, metadata, context) =>
+  getTemplateTexts(metadata, context).some((template) => templateReferencesMember(memberName, template)) ||
+  getHostBindings(metadata).some((binding) => textReferencesMember(memberName, binding.expression));
+
+/**
+ * @param {string} memberName
+ * @param {any} metadata
+ * @param {import('eslint').Rule.RuleContext} context
+ */
+const isWrittenFromTemplateOrHostMetadata = (memberName, metadata, context) =>
+  getTemplateTexts(metadata, context).some((template) => templateWritesMember(memberName, template)) ||
+  getHostBindings(metadata).some(
+    (binding) => isWritingBinding(binding.name) && textReferencesMember(memberName, binding.expression),
+  );
+
 /**
  * @param {any} node
  */
@@ -252,8 +387,24 @@ const isReferencedFromTemplateOrHost = (classNode, memberName, context) => {
   return isReferencedFromTemplateOrHostMetadata(memberName, angularMetadata.metadata, context);
 };
 
+/**
+ * @param {any} classNode
+ * @param {string} memberName
+ * @param {import('eslint').Rule.RuleContext} context
+ */
+const isWrittenFromTemplateOrHost = (classNode, memberName, context) => {
+  const angularMetadata = getAngularMetadata(context.sourceCode, classNode);
+
+  if (!angularMetadata) {
+    return false;
+  }
+
+  return isWrittenFromTemplateOrHostMetadata(memberName, angularMetadata.metadata, context);
+};
+
 module.exports = {
   getAngularMetadata,
+  isWrittenFromTemplateOrHost,
   getMemberName,
   isReferencedFromTemplateOrHost,
 };

package/src/rules/no-enum.js

@@ -73,21 +73,49 @@ const noEnum = {
       const memberIndent = `${indent}  `;
       const exported = target.type === 'ExportNamedDeclaration' ? 'export ' : '';
 
-      const lines = membersOf(node).flatMap((member) => {
-        const comments = sourceCode.getCommentsBefore(member).flatMap((comment) =>
-          sourceCode
-            .getText(comment)
-            .split('\n')
-            // A block comment's continuation lines carry one more space so the leading `*` stays aligned.
-            .map((line, index) => `${memberIndent}${index === 0 ? '' : ' '}${line.trim()}`),
+      const members = membersOf(node);
+      const openBrace = sourceCode.getTokenBefore(members[0], { filter: (token) => token.value === '{' });
+      const bodyStart = openBrace ? openBrace.range[1] : node.id.range[1];
+      const bodyComments = sourceCode.getCommentsInside(node).filter((comment) => comment.range[0] >= bodyStart);
+
+      const formatComment = (comment) =>
+        sourceCode
+          .getText(comment)
+          .split('\n')
+          // A block comment's continuation lines carry one more space so the leading `*` stays aligned.
+          .map((line, index) => `${memberIndent}${index === 0 ? '' : ' '}${line.trim()}`);
+
+      const trailingOf = new Map(members.map((member) => [member, []]));
+      const leadingOf = new Map(members.map((member) => [member, []]));
+      const afterLast = [];
+
+      for (const comment of bodyComments) {
+        const owner = members.find(
+          (member) => member.loc.end.line === comment.loc.start.line && member.range[1] <= comment.range[0],
         );
 
+        if (owner) {
+          trailingOf.get(owner).push(comment);
+          continue;
+        }
+
+        const next = members.find((member) => member.range[0] >= comment.range[1]);
+        (next ? leadingOf.get(next) : afterLast).push(comment);
+      }
+
+      const lines = members.flatMap((member) => {
         const key = sourceCode.getText(member.id);
         const value = sourceCode.getText(member.initializer);
+        const trailing = trailingOf
+          .get(member)
+          .map((comment) => ` ${sourceCode.getText(comment)}`)
+          .join('');
 
-        return [...comments, `${memberIndent}${key}: ${value},`];
+        return [...leadingOf.get(member).flatMap(formatComment), `${memberIndent}${key}: ${value},${trailing}`];
       });
 
+      lines.push(...afterLast.flatMap(formatComment));
+
       return [
         `${exported}const ${name} = {`,
         ...lines,

package/src/rules/no-leading-underscore-class-member.js

@@ -26,6 +26,20 @@ const getReferencedName = (key, computed) => {
   return null;
 };
 
+/**
+ * @param {any} thisExpression
+ * @param {any} classBody
+ */
+const isClassThis = (thisExpression, classBody) => {
+  for (let node = thisExpression.parent; node && node !== classBody; node = node.parent) {
+    if (node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration') {
+      return node.parent?.type.endsWith('MethodDefinition') && node.parent.parent === classBody;
+    }
+  }
+
+  return true;
+};
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noLeadingUnderscoreClassMember = {
   meta: {
@@ -155,7 +169,8 @@ const noLeadingUnderscoreClassMember = {
         if (!frame) return;
 
         if (node.object?.type === 'ThisExpression' && !node.computed && node.property?.type === 'Identifier') {
-          frame.memberReads.push(node);
+          if (isClassThis(node.object, frame.classBody)) frame.memberReads.push(node);
+          else frame.untrackedNames.add(node.property.name);
           return;
         }
 

package/src/rules/no-legacy-angular-decorators.js

@@ -98,37 +98,57 @@ const findObjectProperty = (objectExpression, propertyName) =>
     (property) => property.type === 'Property' && getPropertyName(property.key) === propertyName,
   ) ?? null;
 
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} token
+ */
+const getEndOfSameLineComments = (sourceCode, token) => {
+  let end = token.range[1];
+
+  for (const comment of sourceCode.getCommentsAfter(token)) {
+    if (comment.loc?.start.line !== token.loc.end.line) break;
+    end = comment.range?.[1] ?? end;
+  }
+
+  return end;
+};
+
 /**
  * @param {import('eslint').SourceCode} sourceCode
  * @param {any} objectExpression
  * @param {string} entryText
+ * @returns {(fixer: import('eslint').Rule.RuleFixer) => import('eslint').Rule.Fix[]}
  */
-const buildObjectTextWithAppendedProperty = (sourceCode, objectExpression, entryText) => {
+const buildAppendPropertyFix = (sourceCode, objectExpression, entryText) => {
   const properties = objectExpression.properties;
   const isMultiline = Boolean(
     objectExpression.loc && objectExpression.loc.start.line !== objectExpression.loc.end.line,
   );
-
-  if (!isMultiline) {
-    const existingText = properties.map((property) => sourceCode.getText(property));
-    return existingText.length === 0 ? `{ ${entryText} }` : `{ ${existingText.join(', ')}, ${entryText} }`;
-  }
-
   const closingBrace = sourceCode.getLastToken(objectExpression);
   const closingIndent = closingBrace ? getIndent(sourceCode, closingBrace) : '';
-  const propertyIndent = properties[0] ? getIndent(sourceCode, properties[0]) : `${closingIndent}  `;
-  const existingText = properties.map((property) => `${propertyIndent}${sourceCode.getText(property)}`);
+  const lastProperty = properties.at(-1);
 
-  if (existingText.length === 0) {
-    return `{
-${propertyIndent}${entryText}
-${closingIndent}}`;
+  if (!lastProperty) {
+    const insertion = isMultiline ? `\n${closingIndent}  ${entryText}\n${closingIndent}` : ` ${entryText} `;
+    return (fixer) => [
+      fixer.replaceTextRange([objectExpression.range[0] + 1, objectExpression.range[1] - 1], insertion),
+    ];
+  }
+
+  const propertyIndent = getIndent(sourceCode, properties[0]);
+  const tokenAfter = sourceCode.getTokenAfter(lastProperty);
+  const hasComma = tokenAfter?.type === 'Punctuator' && tokenAfter.value === ',';
+  const anchorToken = hasComma ? tokenAfter : sourceCode.getLastToken(lastProperty);
+  const insertAt = isMultiline ? getEndOfSameLineComments(sourceCode, anchorToken) : anchorToken.range[1];
+  const entry = isMultiline
+    ? `\n${propertyIndent}${entryText}${hasComma ? ',' : ''}`
+    : ` ${entryText}${hasComma ? ',' : ''}`;
+
+  if (hasComma || insertAt === lastProperty.range[1]) {
+    return (fixer) => [fixer.insertTextAfterRange([insertAt, insertAt], `${hasComma ? '' : ','}${entry}`)];
   }
 
-  return `{
-${existingText.join(',\n')},
-${propertyIndent}${entryText}
-${closingIndent}}`;
+  return (fixer) => [fixer.insertTextAfter(lastProperty, ','), fixer.insertTextAfterRange([insertAt, insertAt], entry)];
 };
 
 /**
@@ -172,12 +192,7 @@ const buildHostBindingFix = (sourceCode, decoratorNode, memberNode, bindingKey,
       return null;
     }
 
-    fixes.push((fixer) =>
-      fixer.replaceText(
-        hostProperty.value,
-        buildObjectTextWithAppendedProperty(sourceCode, hostProperty.value, hostEntryText),
-      ),
-    );
+    fixes.push(buildAppendPropertyFix(sourceCode, hostProperty.value, hostEntryText));
   } else {
     const closingBrace = sourceCode.getLastToken(metadata);
     if (!closingBrace) return null;
@@ -216,7 +231,7 @@ const buildHostBindingFix = (sourceCode, decoratorNode, memberNode, bindingKey,
       : (fixer) => fixer.remove(decoratorNode),
   );
 
-  return (fixer) => fixes.map((applyFix) => applyFix(fixer));
+  return (fixer) => fixes.flatMap((applyFix) => applyFix(fixer));
 };
 
 /** @type {import('eslint').Rule.RuleModule} */

package/src/rules/no-readonly-signal.js

@@ -70,7 +70,7 @@ const noReadonlySignal = {
     },
     messages: {
       noReadonlySignal:
-        "Remove `readonly` from '{{name}}' — reactive APIs return mutable references, and `readonly` gives a false sense of immutability.",
+        "Remove `readonly` from '{{name}}' — {{api}}() returns a mutable reference, and `readonly` gives a false sense of immutability.",
     },
     schema: [],
   },
@@ -99,7 +99,7 @@ const noReadonlySignal = {
           context.report({
             node,
             messageId: 'noReadonlySignal',
-            data: { name: apiName },
+            data: { name: context.sourceCode.getText(node.key), api: apiName },
             fix(fixer) {
               const sourceCode = context.sourceCode;
               const tokens = sourceCode.getTokens(node);

package/src/rules/no-trivial-return-type.js

@@ -40,14 +40,16 @@ const TRIVIAL_LABELS = {
 const noTrivialReturnType = {
   meta: {
     type: 'suggestion',
-    fixable: 'code',
+    hasSuggestions: true,
     docs: {
       description:
         'Disallow explicit return type annotations that TypeScript can infer (void, boolean, string, number, undefined, null).',
       recommended: true,
     },
     messages: {
-      trivialReturnType: "Omit the explicit ': {{type}}' return type — TypeScript infers it.",
+      trivialReturnType:
+        "Omit the explicit ': {{type}}' return type — TypeScript infers it. Keep it when the returned value is `any`, or the inferred type would differ.",
+      removeReturnType: "Remove the ': {{type}}' return type.",
     },
     schema: [],
   },
@@ -199,9 +201,13 @@ const noTrivialReturnType = {
         node: fn.returnType,
         messageId: 'trivialReturnType',
         data: { type: label },
-        fix(fixer) {
-          return fixer.remove(fn.returnType);
-        },
+        suggest: [
+          {
+            messageId: 'removeReturnType',
+            data: { type: label },
+            fix: (fixer) => fixer.remove(fn.returnType),
+          },
+        ],
       });
     };
 

package/src/rules/no-unused-class-member.js

@@ -112,10 +112,10 @@ const noUnusedClassMember = {
     },
     messages: {
       noUnused:
-        "'{{name}}' is declared but never referenced through `this` within this class. " +
+        "'{{name}}' is declared but never referenced within this class. " +
         'Remove it, or widen its accessibility if it is intentionally used externally.',
       noUnusedProtected:
-        "'{{name}}' is protected but never referenced through `this` within this class. " +
+        "'{{name}}' is protected but never referenced within this class. " +
         'If a subclass reads it, mark this class `abstract`; otherwise remove it.',
     },
     schema: [],
@@ -199,7 +199,6 @@ const noUnusedClassMember = {
       AccessorProperty: registerMember,
 
       MemberExpression(node) {
-        if (node.object?.type !== 'ThisExpression') return;
         const name =
           !node.computed && node.property?.type === 'Identifier'
             ? node.property.name
@@ -208,6 +207,11 @@ const noUnusedClassMember = {
               : null;
         if (!name) return;
 
+        if (node.object?.type !== 'ThisExpression') {
+          for (const frame of classStack) frame.usedNames.add(name);
+          return;
+        }
+
         // Mark used in the innermost class frame. Arrow functions don't push a
         // new frame so they correctly share the enclosing class's `this`.
         // Regular nested classes push a new frame so their `this.x` won't

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

@@ -19,6 +19,33 @@ const { isImportedAs } = require('./internals/import-resolution');
  *   ).subscribe();
  */
 
+const ALLOWED_AFTER = new Set([
+  'finalize',
+  'defaultIfEmpty',
+  'endWith',
+  'toArray',
+  'last',
+  'count',
+  'reduce',
+  'takeLast',
+]);
+
+/**
+ * @param {any} node
+ */
+const isPipeCall = (node) =>
+  node?.type === 'CallExpression' &&
+  node.callee.type === 'MemberExpression' &&
+  !node.callee.computed &&
+  node.callee.property.type === 'Identifier' &&
+  node.callee.property.name === 'pipe';
+
+/**
+ * @param {any} node
+ */
+const isAllowedAfter = (node) =>
+  node.type === 'CallExpression' && node.callee.type === 'Identifier' && ALLOWED_AFTER.has(node.callee.name);
+
 /** @type {import('eslint').Rule.RuleModule} */
 const takeUntilDestroyedLast = {
   meta: {
@@ -29,7 +56,7 @@ const takeUntilDestroyedLast = {
     },
     messages: {
       takeUntilDestroyedLast:
-        'takeUntilDestroyed() must be the last operator in the pipe. An operator after it (switchMap, shareReplay, …) can keep the subscription alive after destroy.',
+        'takeUntilDestroyed() must be the last operator in the pipe. An operator after it that subscribes to an inner or shared source (switchMap, mergeMap, share without refCount, …) outlives destroy. Move takeUntilDestroyed() after it.',
     },
     schema: [],
   },
@@ -41,20 +68,22 @@ const takeUntilDestroyedLast = {
 
     return {
       CallExpression(node) {
-        const { callee } = node;
-        if (
-          callee.type !== 'MemberExpression' ||
-          callee.property.type !== 'Identifier' ||
-          callee.property.name !== 'pipe'
-        ) {
-          return;
+        if (!isPipeCall(node)) return;
+
+        const parent = /** @type {any} */ (node).parent;
+        if (parent?.type === 'MemberExpression' && parent.object === node && isPipeCall(parent.parent)) return;
+
+        /** @type {any[]} */
+        const operators = [];
+        for (let call = /** @type {any} */ (node); isPipeCall(call); call = call.callee.object) {
+          operators.unshift(...call.arguments);
         }
 
-        const lastIndex = node.arguments.length - 1;
-        node.arguments.forEach((arg, index) => {
-          if (index < lastIndex && isTakeUntilDestroyedCall(arg)) {
-            context.report({ node: arg, messageId: 'takeUntilDestroyedLast' });
-          }
+        operators.forEach((operator, index) => {
+          if (!isTakeUntilDestroyedCall(operator)) return;
+          if (operators.slice(index + 1).every(isAllowedAfter)) return;
+
+          context.report({ node: operator, messageId: 'takeUntilDestroyedLast' });
         });
       },
     };