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

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # 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
+
+- [#3069](https://github.com/ethlete-io/ethdk/pull/3069) [`a9113cb`](https://github.com/ethlete-io/ethdk/commit/a9113cb6ce63942ffce0e26ca7df7f0556a14838) Thanks [@github-actions](https://github.com/apps/github-actions)! - New rule `ethlete/no-enum`. It bans `enum` and `const enum`, and auto-fixes a string enum into a
+  const object plus a derived union type.
+
+### Patch Changes
+
+- [#3069](https://github.com/ethlete-io/ethdk/pull/3069) [`a9113cb`](https://github.com/ethlete-io/ethdk/commit/a9113cb6ce63942ffce0e26ca7df7f0556a14838) Thanks [@github-actions](https://github.com/apps/github-actions)! - Harden unsafe fixers, reduce contract and test false positives, and correct replacement guidance across the recommended rules.
+
 ## 1.0.0-next.22
 
 ### Patch Changes

package/package.json

@@ -1,15 +1,14 @@
 {
   "name": "@ethlete/eslint-plugin",
-  "version": "1.0.0-next.22",
+  "version": "1.0.0-next.24",
   "license": "MIT",
   "type": "commonjs",
   "main": "./src/index.js",
   "peerDependencies": {
     "@angular-eslint/eslint-plugin-template": ">=21.0.0",
-    "@angular/core": "22.0.7",
+    "@angular/core": ">=21.0.0",
     "@typescript-eslint/eslint-plugin": ">=8.0.0",
     "eslint": ">=9.0.0",
-    "tslib": "2.8.1",
-    "typescript": "6.0.3"
+    "typescript": ">=5.9.0"
   }
-}
+}

package/src/configs/recommended.js

@@ -107,11 +107,8 @@ const recommendedTs = {
 
     'no-restricted-syntax': [
       'error',
-      // No enum — use const object + derived union type
-      {
-        selector: 'TSEnumDeclaration',
-        message: 'No enums. Use a const object + derived union type instead.',
-      },
+      // enum / const enum is owned by ethlete/no-enum, so a lib can keep it on while it works
+      // through the rest of this rule's backlog.
       // No standalone function declarations / expressions — use arrow functions
       {
         selector: 'FunctionDeclaration',
@@ -242,9 +239,15 @@ 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',
 
+    // No enum / const enum — use a const object with `as const` plus a derived union type
+    'ethlete/no-enum': 'error',
+
     // No .subscribe() inside effect() or computed()
     'ethlete/no-rxjs-in-effect': 'error',
 
@@ -272,7 +275,7 @@ const recommendedTs = {
     // No raw IntersectionObserver / MutationObserver / ResizeObserver — use @ethlete/core signal utils
     'ethlete/no-native-observers': 'error',
 
-    // Prefer injectViewportSize() over window.innerWidth / innerHeight / outerWidth / outerHeight
+    // Prefer injectViewportSize() over window.innerWidth / innerHeight
     'ethlete/prefer-viewport-size': 'warn',
 
     // Prefer injectMediaQueryIsMatched() / injectBreakpointIsMatched() etc. over .matchMedia()
@@ -297,7 +300,7 @@ const recommendedTs = {
     'ethlete/no-legacy-angular-decorators': 'error',
 
     // No Angular Title/Meta services — use @ethlete/core SEO utilities instead
-    // (injectTitleBinding, injectMetaBinding, injectLinkBinding, etc.)
+    // (applyHeadTitleBinding, applyMetaBinding, applyLinkBinding, etc.)
     'ethlete/no-angular-seo-services': 'error',
 
     // No JSON.parse(JSON.stringify()), structuredClone, or lodash cloneDeep / isEqual
@@ -414,20 +417,30 @@ const recommendedTemplate = {
     // (warn + suggestion-only: the rewrite is only safe when the input has a booleanAttribute transform,
     // which a template rule cannot verify)
     'ethlete/prefer-static-boolean-properties': 'warn',
-    // A form must handle its own submission, and a type="submit" control must reach a form
+    // A form must handle its own submission
     'ethlete/require-form-submit': 'error',
   },
 };
 
 /**
- * Relaxed rules for test/spec files.
- * Non-null assertions are common and intentional in tests.
+ * Relaxed rules for test/spec files, including common DOM assertions and async test orchestration.
  * @type {import('eslint').Linter.Config}
  */
 const recommendedSpec = {
   files: ['**/*.spec.ts'],
   rules: {
     '@typescript-eslint/no-non-null-assertion': 'off',
+    'no-restricted-globals': 'off',
+    'ethlete/no-async-await': 'off',
+    'ethlete/no-direct-dom-manipulation': 'off',
+    'ethlete/no-document-cookie': 'off',
+    'ethlete/no-dom-query': 'off',
+    'ethlete/no-native-observers': 'off',
+    'ethlete/no-window-location': 'off',
+    'ethlete/prefer-element-dimensions': 'off',
+    'ethlete/prefer-match-media': 'off',
+    'ethlete/prefer-scroll-state': 'off',
+    'ethlete/prefer-viewport-size': 'off',
   },
 };
 

package/src/index.js

@@ -59,19 +59,23 @@ const requireFormSubmit = require('./rules/require-form-submit');
 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');
 
 /** @type {import('eslint').ESLint.Plugin} */
 const plugin = {
   meta: {
     name: '@ethlete/eslint-plugin',
-    version: '0.0.1',
+    version,
   },
   rules: {
     'no-inject-chain': noInjectChain,
     '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,
@@ -126,6 +130,7 @@ const plugin = {
     'no-cdk-import': noCdkImport,
     'no-legacy-query-import': noLegacyQueryImport,
     'no-async-await': noAsyncAwait,
+    'no-enum': noEnum,
   },
 };
 

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',
@@ -249,6 +243,11 @@ const collectWrittenMembers = (node, writtenMembers) => {
 
   if (node.type === 'AssignmentExpression') {
     collectAssignedMemberNames(node.left, writtenMembers);
+
+    if (node.left.type === 'MemberExpression' && node.left.object.type === 'MemberExpression') {
+      const memberName = getWrittenMemberName(node.left.object);
+      if (memberName !== null) writtenMembers.add(memberName);
+    }
   }
 
   if (node.type === 'UpdateExpression') {
@@ -259,6 +258,20 @@ const collectWrittenMembers = (node, writtenMembers) => {
     }
   }
 
+  if (
+    node.type === 'CallExpression' &&
+    node.callee.type === 'MemberExpression' &&
+    node.callee.object.type === 'MemberExpression' &&
+    !node.callee.computed &&
+    node.callee.property.type === 'Identifier' &&
+    ['add', 'clear', 'delete', 'pop', 'push', 'reverse', 'set', 'shift', 'sort', 'splice', 'unshift'].includes(
+      node.callee.property.name,
+    )
+  ) {
+    const memberName = getWrittenMemberName(node.callee.object);
+    if (memberName !== null) writtenMembers.add(memberName);
+  }
+
   for (const [key, value] of Object.entries(node)) {
     if (key === 'parent' || key === 'range' || key === 'loc') continue;
     if (!value || typeof value !== 'object') continue;
@@ -326,7 +339,15 @@ const classConstantProperty = {
             continue;
           }
 
-          if (memberName === 'transform' && hasPipeDecorator(node.parent)) {
+          if (
+            !member.readonly &&
+            ((member.value.type === 'Literal' && member.value.value === null) ||
+              (member.value.type === 'Identifier' && member.value.name === 'undefined'))
+          ) {
+            continue;
+          }
+
+          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/guard-return-newline.js

@@ -58,7 +58,6 @@ const rule = {
         const prevEndLine = prevStatement.loc.end.line;
         const returnStartLine = node.loc.start.line;
 
-        // Need at least one empty line (gap of 2+ lines) between prev statement and return
         if (returnStartLine - prevEndLine >= 2) return;
 
         const sourceCode = context.sourceCode;
@@ -67,10 +66,12 @@ const rule = {
           node,
           messageId: 'missingEmptyLine',
           fix(fixer) {
-            const prevToken = sourceCode.getLastToken(/** @type {import('eslint').Rule.Node} */ (prevStatement));
-            if (!prevToken) return null;
+            const trailingComment = sourceCode
+              .getCommentsAfter(/** @type {import('eslint').Rule.Node} */ (prevStatement))
+              .find((comment) => comment.loc.start.line === prevEndLine && comment.range[1] < node.range[0]);
+            const insertionNode = trailingComment ?? prevStatement;
 
-            return fixer.insertTextAfter(prevToken, '\n');
+            return fixer.insertTextAfter(insertionNode, '\n');
           },
         });
       },