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

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # 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
+
+- `recommendedSpec` also covers `*.test.ts`, stories and `e2e/`, `no-trivial-wrapper-method` allows public methods over private members, and two other rules get fixes.
+
+### Patch Changes
+
+- Angular metadata fixers (`no-legacy-angular-decorators`, `require-on-push-change-detection`, `require-view-encapsulation-none`) now insert properties with the surrounding comma style and no stray spaces.
+- `class-member-order`: the fixer keeps blank lines between members in place instead of leaving one after the opening brace.
+- `no-inject-chain` no longer reports a constructor called straight off `inject()`, as in `new (inject(Foo).Bar)()`.
+- `no-subscribe-in-pipe` no longer reports a `.subscribe()` inside a callback of the observable that `.pipe()` is called on, such as `defer(() => …).pipe(…)`.
+- `template-member-accessibility` now fixes an unneeded `protected` to `public` in one pass, instead of deleting it (and any comment after it) and leaving an implicitly public member to fix again.
+- The `no-unused-class-member` message now says the member is never referenced through `this`, matching what the rule checks: a member that is only written still counts as used.
+- Mark every migration with a `level`, so `et update` runs only the required ones.
+- `enforce-routing-view-naming` only checks object literals that have a `path` key.
+
 ## 1.0.0-next.26
 
 ### Minor Changes

package/README.md

@@ -17,6 +17,10 @@ import ethlete from '@ethlete/eslint-plugin';
 export default [...ethlete.configs.recommended];
 ```
 
+Composing the configs one by one (`recommendedTs`, `recommendedAngularTs`, `recommendedTemplate`)?
+Add `ethlete.configs.recommendedSpec` as the last entry - without it, specs, stories and test
+harnesses are linted with the strict rules.
+
 ## Documentation
 
 The full rule reference (all rules, grouped, with defaults and auto-fix support) and

package/migrations.json

@@ -4,6 +4,7 @@
       "name": "module-augmentation-interfaces",
       "version": "1.0.0-next.25",
       "kind": "auto",
+      "level": "required",
       "description": "Turn the type aliases the old consistent-type-definitions fix left in declare module / declare global blocks back into interfaces, and rename its eslint-disable directives to ethlete/consistent-type-definitions.",
       "generator": "@ethlete/eslint-plugin:restore-module-augmentation-interfaces",
       "docs": "/eslint/rules"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/eslint-plugin",
-  "version": "1.0.0-next.26",
+  "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.',
       },
@@ -432,13 +433,20 @@ const recommendedTemplate = {
 };
 
 /**
- * Relaxed rules for test/spec files, including common DOM assertions and async test orchestration.
+ * Relaxed rules for specs, test harnesses, stories and e2e files: DOM assertions, async test
+ * orchestration, collecting emissions in a subscribe body, and fixture helpers with many parameters.
  * @type {import('eslint').Linter.Config}
  */
 const recommendedSpec = {
-  files: ['**/*.spec.ts'],
+  files: ['**/*.spec.ts', '**/*.test.ts', '**/testing/**/*.ts', '**/*.stories.ts', '**/e2e/**/*.ts'],
   rules: {
     '@typescript-eslint/no-non-null-assertion': 'off',
+    'max-params': 'off',
+    'ethlete/no-subscribe-in-pipe': 'off',
+    'ethlete/no-subscribe-with-body': 'off',
+    'ethlete/no-unused-class-member': 'off',
+    'ethlete/prefer-clone-equal': 'off',
+    'ethlete/prefer-rxjs-timer': 'off',
     'no-restricted-globals': 'off',
     'ethlete/no-async-await': 'off',
     'ethlete/no-csp-unsafe': 'off',

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/class-member-order.js

@@ -416,18 +416,24 @@ const buildClassOrderFix = (sourceCode, classBodyNode, members) => {
     rankedIndexes.has(index) ? sortedMembers[nextSortedMember++].originalIndex : index,
   );
 
+  const gaps = segmentTexts.map((text) => /^\s*/.exec(text)?.[0] ?? '');
+  const bodies = segmentTexts.map((text, index) => text.slice(gaps[index].length));
+
   const reorderedBody =
     order
       .map((originalIndex, position) => {
-        const nextIndex = order[position + 1] ?? segmentTexts.length;
-        if (nextIndex === originalIndex + 1) return segmentTexts[originalIndex];
-
-        return joinMovedSegment(
-          sourceCode,
-          classBodyNode.body[originalIndex],
-          segmentTexts[originalIndex],
-          classBodyNode.body[nextIndex] ?? null,
-          segmentTexts[nextIndex] ?? suffix,
+        const nextIndex = order[position + 1];
+        const nextText = nextIndex === undefined ? suffix : gaps[position + 1] + bodies[nextIndex];
+
+        return (
+          gaps[position] +
+          joinMovedSegment(
+            sourceCode,
+            classBodyNode.body[originalIndex],
+            bodies[originalIndex],
+            nextIndex === undefined ? null : classBodyNode.body[nextIndex],
+            nextText,
+          )
         );
       })
       .join('') + suffix;

package/src/rules/enforce-routing-view-naming.js

@@ -2,7 +2,7 @@
 'use strict';
 
 /**
- * Checks that a `loadComponent:` route property:
+ * Checks that a `loadComponent:` property of a route object (one with a `path` key):
  *  1. Imports from a path containing "-view"
  *  2. Accesses a class name ending in "ViewComponent" in the .then() callback
  *
@@ -12,6 +12,17 @@
 
 const VIEW_PATH = /-view(?![\w-])/;
 
+/** @param {any} objectNode */
+const isRoute = (objectNode) =>
+  objectNode?.type === 'ObjectExpression' &&
+  objectNode.properties.some(
+    /** @param {any} prop */ (prop) =>
+      prop.type === 'Property' &&
+      !prop.computed &&
+      ((prop.key.type === 'Identifier' && prop.key.name === 'path') ||
+        (prop.key.type === 'Literal' && prop.key.value === 'path')),
+  );
+
 /** @type {import('eslint').Rule.RuleModule} */
 const enforceRoutingViewNaming = {
   meta: {
@@ -46,6 +57,7 @@ const enforceRoutingViewNaming = {
       Property(node) {
         const key = /** @type {any} */ (node).key;
         if (key.type !== 'Identifier' || key.name !== 'loadComponent') return;
+        if (!isRoute(/** @type {any} */ (node).parent)) return;
 
         const arrow = /** @type {any} */ (node).value;
         if (!arrow || arrow.type !== 'ArrowFunctionExpression') return;

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/internals/angular-metadata-fix.js

@@ -195,7 +195,7 @@ const buildMetadataFix = (sourceCode, metadata, spec) => {
     return (fixer) =>
       fixer.replaceTextRange(
         [rangeStart, closingBrace.range[0]],
-        `${separator}\n${propertyIndent}${propertyText}\n${closingIndent}`,
+        `${separator}\n${propertyIndent}${propertyText}${separator === '' ? ',' : ''}\n${closingIndent}`,
       );
   }
 

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-inject-chain.js

@@ -25,7 +25,11 @@ const noInjectChain = {
           // Allow inject(X).method() — immediately-invoked patterns like
           // inject(DestroyRef).onDestroy(...) are intentional Angular idioms.
           const parent = node.parent;
-          if (parent && parent.type === 'CallExpression' && parent.callee === node) {
+          if (
+            parent &&
+            (parent.type === 'CallExpression' || parent.type === 'NewExpression') &&
+            parent.callee === node
+          ) {
             return;
           }
 

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;
@@ -188,24 +203,22 @@ const buildHostBindingFix = (sourceCode, decoratorNode, memberNode, bindingKey,
       ? getIndent(sourceCode, metadata.properties[0])
       : `${getIndent(sourceCode, closingBrace)}  `;
     const hostPropertyText = `host: { ${hostEntryText} }`;
-    const separator = metadata.properties.length > 0 ? (hasTrailingComma(sourceCode, metadata) ? '' : ',') : '';
+    const lastProperty = metadata.properties.at(-1);
 
-    if (isMultiline && metadata.properties.length > 0) {
-      const lastProperty = metadata.properties[metadata.properties.length - 1];
+    if (lastProperty) {
+      const separator = hasTrailingComma(sourceCode, metadata) ? '' : ',';
       const tokenAfterLastProperty = sourceCode.getTokenAfter(lastProperty);
       const rangeStart =
         separator === '' && tokenAfterLastProperty ? tokenAfterLastProperty.range[1] : lastProperty.range[1];
+      const replacement = isMultiline
+        ? `${separator}\n${propertyIndent}${hostPropertyText}${separator === '' ? ',' : ''}\n${closingIndent}`
+        : `${separator} ${hostPropertyText} `;
 
-      fixes.push((fixer) =>
-        fixer.replaceTextRange(
-          [rangeStart, closingBrace.range[0]],
-          `${separator}\n${propertyIndent}${hostPropertyText},\n${closingIndent}`,
-        ),
-      );
+      fixes.push((fixer) => fixer.replaceTextRange([rangeStart, closingBrace.range[0]], replacement));
     } else {
       const insertion = isMultiline
         ? `\n${propertyIndent}${hostPropertyText}\n${closingIndent}`
-        : `${metadata.properties.length > 0 ? `${separator} ` : ' '}${hostPropertyText}${metadata.properties.length > 0 ? '' : ' '}`;
+        : ` ${hostPropertyText} `;
 
       fixes.push((fixer) => fixer.insertTextBefore(closingBrace, insertion));
     }
@@ -218,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-subscribe-in-pipe.js

@@ -43,6 +43,8 @@ const noSubscribeInPipe = {
      */
     const isInsidePipeCallback = (node) => {
       let crossedFunctionBoundary = false;
+      /** @type {import('eslint').Rule.Node} */
+      let previous = node;
       let current = node.parent;
       while (current) {
         // A `new Observable(factory)` is its own subscription boundary — subscribing
@@ -62,10 +64,12 @@ const noSubscribeInPipe = {
           current.type === 'CallExpression' &&
           current.callee.type === 'MemberExpression' &&
           current.callee.property.type === 'Identifier' &&
-          current.callee.property.name === 'pipe'
+          current.callee.property.name === 'pipe' &&
+          current.arguments.includes(/** @type {any} */ (previous))
         ) {
           return true;
         }
+        previous = current;
         current = current.parent;
       }
       return false;

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-trivial-wrapper-method.js

@@ -17,6 +17,8 @@ const { getAngularDecoratorName } = require('./internals/import-resolution');
  *
  * GOOD:
  *   // Call this.value.set(val) directly at the call sites.
+ *   // A public method over a private/protected member is the encapsulation, not a wrapper:
+ *   //   private items = signal([]); setItems(items) { this.items.set(items); }
  *   // If the method wraps something non-trivially (transforms args, adds logic), it is fine.
  *   // `focus`/`blur`/`reset` on a @Component/@Directive are exempt - see CONTRACT_METHOD_NAMES.
  */
@@ -92,6 +94,39 @@ const getTrivialCallExpr = (methodNode) => {
   return allMatch ? callExpr : null;
 };
 
+/** @param {any} member */
+const visibilityOf = (member) => {
+  if (member.key?.type === 'PrivateIdentifier' || member.accessibility === 'private') return 0;
+  if (member.accessibility === 'protected') return 1;
+  return 2;
+};
+
+/**
+ * @param {any} classBody
+ * @param {any} callee
+ */
+const receiverVisibility = (classBody, callee) => {
+  let object = callee;
+  while (object.type === 'MemberExpression' && object.object.type !== 'ThisExpression') object = object.object;
+  if (object.type !== 'MemberExpression' || object.computed) return undefined;
+
+  const name = object.property.type === 'PrivateIdentifier' ? `#${object.property.name}` : object.property.name;
+  /** @param {any} key */
+  const keyName = (key) => (key?.type === 'PrivateIdentifier' ? `#${key.name}` : key?.name);
+
+  for (const member of classBody.body) {
+    if (member.type === 'MethodDefinition' && member.kind === 'constructor') {
+      const property = member.value.params.find(
+        (/** @type {any} */ param) => param.type === 'TSParameterProperty' && param.parameter.name === name,
+      );
+      if (property) return visibilityOf(property);
+      continue;
+    }
+    if (keyName(member.key) === name) return visibilityOf(member);
+  }
+  return undefined;
+};
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noTrivialWrapperMethod = {
   meta: {
@@ -102,7 +137,7 @@ const noTrivialWrapperMethod = {
     },
     messages: {
       noTrivialWrapperMethod:
-        "'{{name}}' is a trivial wrapper — it only forwards all its arguments to '{{target}}'. Remove it and call '{{target}}' directly at each call site.",
+        "'{{name}}' is a trivial wrapper — it only forwards all its arguments to '{{target}}', which callers can already reach. Remove it and call '{{target}}' directly at each call site.",
     },
     schema: [],
   },
@@ -133,6 +168,9 @@ const noTrivialWrapperMethod = {
 
         if (!targetName) return;
 
+        const wrapped = receiverVisibility(node.parent, callee);
+        if (wrapped !== undefined && visibilityOf(node) > wrapped) return;
+
         context.report({
           node,
           messageId: 'noTrivialWrapperMethod',

package/src/rules/no-type-only-import.js

@@ -1,6 +1,25 @@
 // @ts-check
 'use strict';
 
+/** @param {any} node */
+const renderValueImport = (node) => {
+  const clauses = [];
+  const named = [];
+
+  for (const s of node.specifiers) {
+    if (s.type === 'ImportDefaultSpecifier') clauses.push(s.local.name);
+    else if (s.type === 'ImportNamespaceSpecifier') clauses.push(`* as ${s.local.name}`);
+    else {
+      const imported = s.imported.type === 'Identifier' ? s.imported.name : `'${s.imported.value}'`;
+      named.push(s.local.name === imported ? imported : `${imported} as ${s.local.name}`);
+    }
+  }
+
+  if (named.length) clauses.push(`{ ${named.join(', ')} }`);
+
+  return `import ${clauses.join(', ')} from '${node.source.value}';`;
+};
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noTypeOnlyImport = {
   meta: {
@@ -11,10 +30,9 @@ const noTypeOnlyImport = {
     },
     fixable: 'code',
     messages: {
-      noTypeImportDeclaration:
-        "Do not use `import type`. Use a regular import instead: `import { {{specifiers}} } from '{{source}}';`.",
+      noTypeImportDeclaration: 'Do not use `import type`. Use a regular import instead: `{{replacement}}`.',
       noInlineTypeSpecifier:
-        "Do not use inline `type` on import specifiers. Use a regular import instead: `import { {{specifiers}} } from '{{source}}';`.",
+        'Do not use inline `type` on import specifiers. Use a regular import instead: `{{replacement}}`.',
     },
     schema: [],
   },
@@ -23,13 +41,10 @@ const noTypeOnlyImport = {
       ImportDeclaration(node) {
         const decl = /** @type {any} */ (node);
         if (decl.importKind === 'type') {
-          const source = /** @type {string} */ (node.source.value);
-          const specifiers = node.specifiers.map((s) => s.local.name).join(', ');
-
           context.report({
             node,
             messageId: 'noTypeImportDeclaration',
-            data: { specifiers, source },
+            data: { replacement: renderValueImport(node) },
             fix(fixer) {
               const sourceCode = context.sourceCode;
               const importToken = sourceCode.getFirstToken(node);
@@ -47,21 +62,10 @@ const noTypeOnlyImport = {
         for (const specifier of node.specifiers) {
           const spec = /** @type {any} */ (specifier);
           if (specifier.type === 'ImportSpecifier' && spec.importKind === 'type') {
-            const source = /** @type {string} */ (node.source.value);
-            const allSpecifiers = node.specifiers
-              .map((s) => {
-                if (s.type === 'ImportSpecifier') {
-                  const imported = s.imported.type === 'Identifier' ? s.imported.name : s.imported.value;
-                  return s.local.name === imported ? imported : `${imported} as ${s.local.name}`;
-                }
-                return s.local.name;
-              })
-              .join(', ');
-
             context.report({
               node: specifier,
               messageId: 'noInlineTypeSpecifier',
-              data: { specifiers: allSpecifiers, source },
+              data: { replacement: renderValueImport(node) },
               fix(fixer) {
                 const sourceCode = context.sourceCode;
                 const tokenBefore = sourceCode.getTokenBefore(specifier.imported ?? specifier.local);

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

@@ -4,13 +4,13 @@
 const { getAngularDecoratorName } = require('./internals/import-resolution');
 
 /**
- * Disallows class members that are declared but never read within the class body.
+ * Disallows class members that are declared but never referenced through `this` within the class body.
  *
  * Only checks members that CANNOT be accessed from outside the class at compile
  * time — so false positives (e.g. template usage) are avoided:
  *
  * - `private` members — always checked. Private members are only accessible
- *   within the class body, so if they are never read there they are dead code.
+ *   within the class body, so if they are never referenced there they are dead code.
  *
  * - `protected` members — checked only when the class has an Angular decorator
  *   other than `@Component` (i.e. `@Directive`, `@Pipe`, `@Injectable`).
@@ -106,13 +106,17 @@ const noUnusedClassMember = {
   meta: {
     type: 'suggestion',
     docs: {
-      description: 'Disallow class members that are declared but never read within the class body.',
+      description:
+        'Disallow class members that are declared but never referenced through `this` within the class body.',
       recommended: true,
     },
     messages: {
       noUnused:
-        "'{{name}}' is declared but its value is never read 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 within this class. " +
+        'If a subclass reads it, mark this class `abstract`; otherwise remove it.',
     },
     schema: [],
   },
@@ -181,7 +185,11 @@ const noUnusedClassMember = {
         if (!frame) return;
         for (const [name, memberNode] of frame.candidates) {
           if (!frame.usedNames.has(name)) {
-            context.report({ node: memberNode, messageId: 'noUnused', data: { name } });
+            context.report({
+              node: memberNode,
+              messageId: memberNode.accessibility === 'protected' ? 'noUnusedProtected' : 'noUnused',
+              data: { name },
+            });
           }
         }
       },
@@ -191,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
@@ -200,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' });
         });
       },
     };

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

@@ -20,21 +20,6 @@ const isInjectCall = (sourceCode, node) => {
   return isImportedAs(sourceCode, node.value.callee, 'inject');
 };
 
-/**
- * @param {any} node
- * @param {import('eslint').SourceCode} sourceCode
- */
-const buildRemoveProtectedFix = (node, sourceCode) => {
-  const protectedToken = sourceCode.getFirstToken(node, (token) => token.value === 'protected');
-  const nextToken = protectedToken ? sourceCode.getTokenAfter(protectedToken) : null;
-
-  if (!protectedToken || !nextToken) {
-    return null;
-  }
-
-  return (fixer) => fixer.removeRange([protectedToken.range[0], nextToken.range[0]]);
-};
-
 const MEMBER_TYPES = new Set([
   'PropertyDefinition',
   'AccessorProperty',
@@ -75,7 +60,7 @@ const templateMemberAccessibility = {
       shouldBeExplicit:
         'Member `{{name}}` is referenced from a template or host binding. Use `public` when it is intentionally exposed outside the component; otherwise use `protected`.',
       shouldNotBeProtected:
-        'Member `{{name}}` should not be protected because it is not referenced from a template or host binding.',
+        'Member `{{name}}` should not be protected because it is not referenced from a template or host binding. If a subclass reads it, mark this class `abstract`.',
     },
   },
   create(context) {
@@ -141,13 +126,13 @@ const templateMemberAccessibility = {
       }
 
       if (node.accessibility !== 'protected') return;
-      if (node.type.startsWith('TSAbstract')) return;
+      if (node.type.startsWith('TSAbstract') || classNode.abstract) return;
 
       context.report({
         node,
         messageId: 'shouldNotBeProtected',
         data: { name: memberName },
-        fix: buildRemoveProtectedFix(node, sourceCode),
+        fix: buildAccessibilityFix(node, sourceCode, 'public'),
       });
 
       return;