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

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 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.27",
   "license": "MIT",
   "type": "commonjs",
   "main": "./src/index.js",

package/src/configs/recommended.js

@@ -432,13 +432,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-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-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-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-legacy-angular-decorators.js

@@ -188,24 +188,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));
     }

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-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 through `this` 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. " +
+        '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 },
+            });
           }
         }
       },

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;