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

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.0.0-next.24
+
+### Minor Changes
+
+- Add `take-until-destroyed-last` to the recommended config: `takeUntilDestroyed()` must be the last operator in a `.pipe()`, since an operator after it can keep the subscription alive.
+
+### Patch Changes
+
+- `class-member-order` now fixes classes with `static` members or index signatures and keeps a trailing comment with its member, and `prefer-concise-angular-host-directives` no longer drops or misplaces comments.
+- Angular and RxJS rules now resolve `Component`, `inject`, `input`, `effect` and friends through their imports, `document` and `setTimeout` match only the globals, and import bans also report re-exports and dynamic imports.
+- Several fixers no longer emit broken code (a dangling `other._value`, a duplicate `styleUrl`, a dropped `host` spread), `no-trivial-return-type` checks function declarations, `no-screaming-case-local` reports a function once, and `standalone` sorts after `selector`.
+
 ## 1.0.0-next.23
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/eslint-plugin",
-  "version": "1.0.0-next.23",
+  "version": "1.0.0-next.24",
   "license": "MIT",
   "type": "commonjs",
   "main": "./src/index.js",
@@ -11,4 +11,4 @@
     "eslint": ">=9.0.0",
     "typescript": ">=5.9.0"
   }
-}
+}

package/src/configs/recommended.js

@@ -239,6 +239,9 @@ const recommendedTs = {
     // No .subscribe() inside a .pipe() callback
     'ethlete/no-subscribe-in-pipe': 'error',
 
+    // takeUntilDestroyed() is the last operator in a .pipe()
+    'ethlete/take-until-destroyed-last': 'error',
+
     // No async/await — asynchronous work is modelled as cold Observables
     'ethlete/no-async-await': 'error',
 

package/src/index.js

@@ -60,6 +60,7 @@ const noCdkImport = require('./rules/no-cdk-import');
 const noLegacyQueryImport = require('./rules/no-legacy-query-import');
 const noAsyncAwait = require('./rules/no-async-await');
 const noEnum = require('./rules/no-enum');
+const takeUntilDestroyedLast = require('./rules/take-until-destroyed-last');
 const { recommendedTs, recommendedTemplate, recommendedSpec } = require('./configs/recommended');
 const { version } = require('../package.json');
 
@@ -74,6 +75,7 @@ const plugin = {
     'no-legacy-prepare-without-injector': noLegacyPrepareWithoutInjector,
     'no-trivial-return-type': noTrivialReturnType,
     'no-subscribe-in-pipe': noSubscribeInPipe,
+    'take-until-destroyed-last': takeUntilDestroyedLast,
     'no-rxjs-in-effect': noRxjsInEffect,
     'no-effect-cleanup-return': noEffectCleanupReturn,
     'no-readonly-signal': noReadonlySignal,

package/src/rules/angular-decorator-property-order.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 /** @typedef {'Component' | 'Directive'} TDecoratorName */
 /** @typedef {{ order: string[]; orderText: string }} TDecoratorConfig */
 /** @typedef {{ range: [number, number] }} TNodeWithRange */
@@ -14,11 +16,13 @@ const DECORATOR_CONFIG = {
   Component: {
     order: [
       'selector',
+      'standalone',
       'template',
       'styleUrl',
       'encapsulation',
       'changeDetection',
       'imports',
+      'deferredImports',
       'providers',
       'viewProviders',
       'animations',
@@ -29,16 +33,28 @@ const DECORATOR_CONFIG = {
       'outputs',
       'queries',
       'preserveWhitespaces',
+      'interpolation',
       'schemas',
       'jit',
       'exportAs',
     ],
     orderText:
-      'selector, template/templateUrl, styleUrl/styleUrls, encapsulation, changeDetection, imports, providers, viewProviders, animations, hostDirectives, host, styles, inputs, outputs, queries, preserveWhitespaces, schemas, jit, exportAs',
+      'selector, standalone, template/templateUrl, styleUrl/styleUrls, encapsulation, changeDetection, imports, deferredImports, providers, viewProviders, animations, hostDirectives, host, styles, inputs, outputs, queries, preserveWhitespaces, interpolation, schemas, jit, exportAs',
   },
   Directive: {
-    order: ['selector', 'exportAs', 'providers', 'inputs', 'outputs', 'queries', 'hostDirectives', 'host', 'jit'],
-    orderText: 'selector, exportAs, providers, inputs, outputs, queries, hostDirectives, host, jit',
+    order: [
+      'selector',
+      'standalone',
+      'exportAs',
+      'providers',
+      'inputs',
+      'outputs',
+      'queries',
+      'hostDirectives',
+      'host',
+      'jit',
+    ],
+    orderText: 'selector, standalone, exportAs, providers, inputs, outputs, queries, hostDirectives, host, jit',
   },
 };
 
@@ -66,22 +82,6 @@ const getOrderKey = (decoratorName, propertyName) => {
   return propertyName;
 };
 
-/**
- * @param {import('eslint').Rule.Node} node
- * @returns {TDecoratorName | null}
- */
-const getDecoratorName = (node) => {
-  const decorator = /** @type {any} */ (node);
-  if (decorator.type !== 'Decorator') return null;
-
-  const expression = decorator.expression;
-  if (expression.type === 'CallExpression') {
-    return expression.callee.type === 'Identifier' ? expression.callee.name : null;
-  }
-
-  return expression.type === 'Identifier' ? expression.name : null;
-};
-
 /** @type {import('eslint').Rule.RuleModule} */
 const angularDecoratorPropertyOrder = {
   meta: {
@@ -101,7 +101,7 @@ const angularDecoratorPropertyOrder = {
     return {
       /** @param {import('eslint').Rule.Node} node */
       Decorator(node) {
-        const decoratorName = getDecoratorName(node);
+        const decoratorName = getAngularDecoratorName(context.sourceCode, node);
         if (decoratorName !== 'Component' && decoratorName !== 'Directive') return;
 
         const decorator = /** @type {any} */ (node);

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

@@ -1,24 +1,18 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 const SCREAMING_CASE_RE = /^[A-Z][A-Z0-9_]*$/;
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} classNode
  */
-const hasPipeDecorator = (classNode) => {
-  const decorators = classNode.decorators ?? [];
-  return decorators.some((/** @type {any} */ dec) => {
-    const expr = dec.expression;
-    if (expr.type === 'CallExpression') {
-      return expr.callee.type === 'Identifier' && expr.callee.name === 'Pipe';
-    }
-    if (expr.type === 'Identifier') {
-      return expr.name === 'Pipe';
-    }
-    return false;
-  });
-};
+const hasPipeDecorator = (sourceCode, classNode) =>
+  (classNode.decorators ?? []).some(
+    (/** @type {any} */ decorator) => getAngularDecoratorName(sourceCode, decorator) === 'Pipe',
+  );
 
 const REACTIVE_APIS = new Set([
   'signal',
@@ -353,7 +347,7 @@ const classConstantProperty = {
             continue;
           }
 
-          if (memberName === 'transform' && hasPipeDecorator(node.parent)) {
+          if (memberName === 'transform' && hasPipeDecorator(context.sourceCode, node.parent)) {
             continue;
           }
 

package/src/rules/class-member-order.js

@@ -1,13 +1,15 @@
 // @ts-check
 'use strict';
 
+const { ANGULAR_CORE, getImportedName } = require('./internals/import-resolution');
+
 /** @typedef {'inject' | 'input' | 'output' | 'query' | 'property' | 'constructor' | 'method' | 'private-method'} TMemberGroup */
 /** @typedef {{ dependencies: Set<string>; group: TMemberGroup; groupIndex: number; name: string; node: any; originalIndex: number }} TMemberEntry */
-/** @typedef {TMemberEntry & { segmentText: string }} TSegmentEntry */
 
 const INPUT_APIS = new Set(['input', 'model']);
 const OUTPUT_APIS = new Set(['output', 'outputFromObservable']);
 const QUERY_APIS = new Set(['viewChild', 'viewChildren', 'contentChild', 'contentChildren']);
+const ANGULAR_API_SOURCES = [ANGULAR_CORE, '@angular/core/rxjs-interop'];
 
 /** @type {TMemberGroup[]} */
 const MEMBER_GROUP_ORDER = [
@@ -71,49 +73,70 @@ const getCallRootName = (value) => {
 };
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} value
+ */
+const getAngularCallName = (sourceCode, value) => {
+  if (!value || value.type !== 'CallExpression') return null;
+
+  const { callee } = value;
+  const isRequired =
+    callee.type === 'MemberExpression' &&
+    !callee.computed &&
+    callee.property.type === 'Identifier' &&
+    callee.property.name === 'required';
+
+  return getImportedName(sourceCode, isRequired ? callee.object : callee, ANGULAR_API_SOURCES);
+};
+
+/**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} node
  * @param {Set<string>} apiNames
  */
-const isPropertyInitializedWith = (node, apiNames) => {
+const isPropertyInitializedWith = (sourceCode, node, apiNames) => {
   if (node.type !== 'PropertyDefinition') return false;
 
-  const apiName = getCallRootName(node.value);
+  const apiName = getAngularCallName(sourceCode, node.value);
   return apiName !== null && apiNames.has(apiName);
 };
 
 const INJECT_HELPER_NAME_PATTERN = /^inject[A-Z]/;
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} node
  */
-const isPropertyInitializedWithInject = (node) => {
+const isPropertyInitializedWithInject = (sourceCode, node) => {
   if (node.type !== 'PropertyDefinition') return false;
+  if (getAngularCallName(sourceCode, node.value) === 'inject') return true;
 
-  const apiName = getCallRootName(node.value);
-  return apiName !== null && (apiName === 'inject' || INJECT_HELPER_NAME_PATTERN.test(apiName));
+  const rootName = getCallRootName(node.value);
+  return rootName !== null && INJECT_HELPER_NAME_PATTERN.test(rootName);
 };
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} node
  * @returns {TMemberGroup | null}
  */
-const getMemberGroup = (node) => {
+const getMemberGroup = (sourceCode, node) => {
   if (node.static) return null;
 
   if (node.type === 'PropertyDefinition') {
-    if (isPropertyInitializedWithInject(node)) {
+    if (isPropertyInitializedWithInject(sourceCode, node)) {
       return 'inject';
     }
 
-    if (isPropertyInitializedWith(node, INPUT_APIS)) {
+    if (isPropertyInitializedWith(sourceCode, node, INPUT_APIS)) {
       return 'input';
     }
 
-    if (isPropertyInitializedWith(node, OUTPUT_APIS)) {
+    if (isPropertyInitializedWith(sourceCode, node, OUTPUT_APIS)) {
       return 'output';
     }
 
-    if (isPropertyInitializedWith(node, QUERY_APIS)) {
+    if (isPropertyInitializedWith(sourceCode, node, QUERY_APIS)) {
       return 'query';
     }
 
@@ -188,12 +211,13 @@ const getInitializerDependencies = (node) => {
 };
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} node
  * @param {number} originalIndex
  * @returns {TMemberEntry | null}
  */
-const toMemberEntry = (node, originalIndex) => {
-  const group = getMemberGroup(node);
+const toMemberEntry = (sourceCode, node, originalIndex) => {
+  const group = getMemberGroup(sourceCode, node);
   const name = getMemberName(node);
 
   if (group === null || name === null) {
@@ -273,12 +297,24 @@ const sortMembers = (members) => {
   return sortedMembers;
 };
 
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} node
+ */
+const getMemberEnd = (sourceCode, node) => {
+  const trailingComments = sourceCode
+    .getCommentsAfter(node)
+    .filter((comment) => comment.loc?.start.line === node.loc.end.line);
+  const lastComment = trailingComments.at(-1);
+
+  return lastComment?.range ? lastComment.range[1] : node.range[1];
+};
+
 /**
  * @param {import('eslint').SourceCode} sourceCode
  * @param {any} classBodyNode
- * @param {TMemberEntry[]} members
  */
-const getSegmentEntries = (sourceCode, classBodyNode, members) => {
+const getSegments = (sourceCode, classBodyNode) => {
   const openingBrace = sourceCode.getFirstToken(classBodyNode);
   const closingBrace = sourceCode.getLastToken(classBodyNode);
 
@@ -288,22 +324,23 @@ const getSegmentEntries = (sourceCode, classBodyNode, members) => {
 
   let segmentStart = openingBrace.range[1];
 
-  const segmentEntries = members.map((member) => {
-    const segmentText = sourceCode.text.slice(segmentStart, member.node.range[1]);
-    segmentStart = member.node.range[1];
+  /** @type {string[]} */
+  const segmentTexts = classBodyNode.body.map(
+    /** @param {any} node */ (node) => {
+      const segmentEnd = getMemberEnd(sourceCode, node);
+      const segmentText = sourceCode.text.slice(segmentStart, segmentEnd);
+      segmentStart = segmentEnd;
 
-    return {
-      ...member,
-      segmentText,
-    };
-  });
+      return segmentText;
+    },
+  );
 
   const suffix = sourceCode.text.slice(segmentStart, closingBrace.range[0]);
 
   return {
     closingBrace,
     openingBrace,
-    segmentEntries,
+    segmentTexts,
     suffix,
   };
 };
@@ -314,43 +351,37 @@ const getSegmentEntries = (sourceCode, classBodyNode, members) => {
  * @param {TMemberEntry[]} members
  */
 const buildClassOrderFix = (sourceCode, classBodyNode, members) => {
-  if (classBodyNode.body.length !== members.length) {
-    return null;
-  }
-
   const sortedMembers = sortMembers(members);
 
   if (!sortedMembers) {
     return null;
   }
 
-  const segments = getSegmentEntries(sourceCode, classBodyNode, members);
+  const isAlreadySorted = sortedMembers.every((member, index) => member === members[index]);
 
-  if (!segments) {
+  if (isAlreadySorted) {
     return null;
   }
 
-  const { closingBrace, openingBrace, segmentEntries, suffix } = segments;
-  const segmentEntriesByOriginalIndex = new Map(
-    segmentEntries.map(
-      /** @param {TSegmentEntry} segmentEntry */ (segmentEntry) => [segmentEntry.originalIndex, segmentEntry],
-    ),
-  );
-  const sortedSegmentEntries = sortedMembers.map((member) => segmentEntriesByOriginalIndex.get(member.originalIndex));
+  const segments = getSegments(sourceCode, classBodyNode);
 
-  if (sortedSegmentEntries.some((entry) => entry === undefined)) {
+  if (!segments) {
     return null;
   }
 
-  const isAlreadySorted = sortedSegmentEntries.every((entry, index) => entry === segmentEntries[index]);
-
-  if (isAlreadySorted) {
-    return null;
-  }
+  const { closingBrace, openingBrace, segmentTexts, suffix } = segments;
+  const rankedIndexes = new Set(members.map((member) => member.originalIndex));
+  let nextSortedMember = 0;
 
-  const reorderedBody = sortedSegmentEntries.map((entry) => entry.segmentText).join('') + suffix;
+  const reorderedBody =
+    segmentTexts
+      .map((segmentText, index) =>
+        rankedIndexes.has(index) ? segmentTexts[sortedMembers[nextSortedMember++].originalIndex] : segmentText,
+      )
+      .join('') + suffix;
 
-  return (fixer) => fixer.replaceTextRange([openingBrace.range[1], closingBrace.range[0]], reorderedBody);
+  return (/** @type {import('eslint').Rule.RuleFixer} */ fixer) =>
+    fixer.replaceTextRange([openingBrace.range[1], closingBrace.range[0]], reorderedBody);
 };
 
 /** @type {import('eslint').Rule.RuleModule} */
@@ -379,7 +410,7 @@ const classMemberOrder = {
         const members = node.body
           .map(
             /** @param {any} member @param {number} originalIndex */ (member, originalIndex) =>
-              toMemberEntry(member, originalIndex),
+              toMemberEntry(sourceCode, member, originalIndex),
           )
           .filter(Boolean);
 

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

@@ -2,15 +2,17 @@
 'use strict';
 
 const { getMemberName, isReferencedFromTemplateOrHost } = require('./internals/angular-member-visibility');
+const { isImportedAs } = require('./internals/import-resolution');
 const { buildAccessibilityFix } = require('./internals/member-accessibility-fix');
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} node
  */
-const isInjectCall = (node) => {
+const isInjectCall = (sourceCode, node) => {
   if (!node || node.type !== 'PropertyDefinition' || !node.value) return false;
   if (node.value.type !== 'CallExpression') return false;
-  return node.value.callee.type === 'Identifier' && node.value.callee.name === 'inject';
+  return isImportedAs(sourceCode, node.value.callee, 'inject');
 };
 
 /** @type {import('eslint').Rule.RuleModule} */
@@ -36,7 +38,7 @@ const injectMemberAccessibility = {
 
     return {
       PropertyDefinition(node) {
-        if (!isInjectCall(node)) return;
+        if (!isInjectCall(context.sourceCode, node)) return;
 
         const classNode = node.parent && node.parent.type === 'ClassBody' ? node.parent.parent : null;
         if (!classNode || (classNode.type !== 'ClassDeclaration' && classNode.type !== 'ClassExpression')) return;

package/src/rules/internals/angular-io.js

@@ -18,6 +18,10 @@
  * (or null when the property is not a reactive I/O declaration).
  */
 
+const { ANGULAR_CORE, getImportedName } = require('./import-resolution');
+
+const ANGULAR_IO_SOURCES = [ANGULAR_CORE, '@angular/core/rxjs-interop'];
+
 /** Factory identifier → I/O kind. */
 const IO_FACTORIES = {
   input: 'input',
@@ -31,42 +35,37 @@ const IO_FACTORIES = {
  * plain form (`input(...)`) and the `.required` member form
  * (`input.required(...)`).
  *
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} callee
  * @returns {string | null}
  */
-const getFactoryName = (callee) => {
+const getFactoryName = (sourceCode, callee) => {
   if (!callee) return null;
 
-  if (callee.type === 'Identifier') return callee.name;
-
-  // input.required(...) / model.required(...)
-  if (
+  const isRequired =
     callee.type === 'MemberExpression' &&
     !callee.computed &&
-    callee.object.type === 'Identifier' &&
     callee.property.type === 'Identifier' &&
-    callee.property.name === 'required'
-  ) {
-    return callee.object.name;
-  }
+    callee.property.name === 'required';
 
-  return null;
+  return getImportedName(sourceCode, isRequired ? callee.object : callee, ANGULAR_IO_SOURCES);
 };
 
 /**
  * Classifies a class property as an Angular signal input/model/output.
  *
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} node  PropertyDefinition
  * @returns {{ kind: 'input' | 'model' | 'output', name: string, keyNode: any } | null}
  */
-const getReactiveIo = (node) => {
+const getReactiveIo = (sourceCode, node) => {
   if (!node || node.type !== 'PropertyDefinition') return null;
   if (node.computed || node.key.type !== 'Identifier') return null;
 
   const value = node.value;
   if (!value || value.type !== 'CallExpression') return null;
 
-  const factory = getFactoryName(value.callee);
+  const factory = getFactoryName(sourceCode, value.callee);
   if (!factory) return null;
 
   if (!Object.hasOwn(IO_FACTORIES, factory)) return null;

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

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./import-resolution');
+
 const fs = require('fs');
 const path = require('path');
 
@@ -10,21 +12,22 @@ const path = require('path');
 const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} decorator
  */
-const getDecoratorCall = (decorator) => {
-  if (!decorator || decorator.type !== 'Decorator') return null;
+const getDecoratorCall = (sourceCode, decorator) => {
+  const name = getAngularDecoratorName(sourceCode, decorator);
+  if (!name) return null;
 
   const expression = decorator.expression;
   if (expression.type !== 'CallExpression') return null;
-  if (expression.callee.type !== 'Identifier') return null;
   if (expression.arguments.length === 0) return null;
 
   const metadata = expression.arguments[0];
   if (!metadata || metadata.type !== 'ObjectExpression') return null;
 
   return {
-    name: expression.callee.name,
+    name,
     metadata,
   };
 };
@@ -135,11 +138,12 @@ const isDynamicHostBindingKey = (keyName) => {
 };
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} classNode
  */
-const getAngularMetadata = (classNode) => {
+const getAngularMetadata = (sourceCode, classNode) => {
   for (const decorator of classNode.decorators || []) {
-    const call = getDecoratorCall(decorator);
+    const call = getDecoratorCall(sourceCode, decorator);
     if (!call) continue;
 
     if (call.name === 'Component' || call.name === 'Directive') {
@@ -217,7 +221,7 @@ const getMemberName = (node) => {
  * @param {import('eslint').Rule.RuleContext} context
  */
 const isReferencedFromTemplateOrHost = (classNode, memberName, context) => {
-  const angularMetadata = getAngularMetadata(classNode);
+  const angularMetadata = getAngularMetadata(context.sourceCode, classNode);
 
   if (!angularMetadata) {
     return false;