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

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 1.0.0-next.26
+
+### Minor Changes
+
+- Drop the last module-scope pins from the components import floor (2,870 B gz) and add a `forbidImpureReads` option to `no-impure-top-level-provider`.
+
+### Patch Changes
+
+- The `class-member-order` fix keeps members without semicolons apart, so the reordered class still parses.
+- `recommendedTemplate` no longer reports an empty `<a>` or `<button>` carrying `et-match-card`, `et-match-participant` or `aria-labelledby` under `@angular-eslint/template/elements-content`.
+- Close rule gaps: `no-document-cookie`, `no-window-location`, `prefer-rxjs-timer`, `no-subscribe-with-body`, `prefer-match-media`, `prefer-clone-equal` and `no-dom-query` catch more escapes, and the `no-async-await` `play` exemption only applies in story files.
+- The `prefer-concise-angular-host-directives` fix no longer lets a trailing line comment swallow the closing brace.
+- Lint-scan fixes: observer, DOM, `accessor`/`abstract`/`static` member and on-push version detection gaps are closed, and importing `constructor` or `toString` from `@ethlete/cdk` or `@ethlete/query` is no longer misread as a mapped symbol.
+- Several rule fixes: `guard-return-newline` no longer counts a comment as the blank line, fixers keep multi-line imports, `no-legacy-prepare-without-injector` accepts `untracked` and IIFEs, `no-cdk-import` re-reads a changed migration map, `router.snapshot` is no longer reported, and `no-rxjs-in-effect` covers `afterRenderEffect` and `linkedSignal`.
+- `no-angular-router-api`, `prefer-element-dimensions`, `prefer-viewport-size` and the legacy query rules report fewer false positives and catch more escapes, and member-visibility rules see files changed during an editor session.
+- Declare `@typescript-eslint/parser` as a peer dependency.
+- Fix several rule gaps: decorator property order keeps trailing comments, `require-dollar-suffix` handles `toObservable` and `asObservable` but not `partition`, and legacy decorator, template literal type, recursion and routing view checks catch more cases.
+
 ## 1.0.0-next.25
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/eslint-plugin",
-  "version": "1.0.0-next.25",
+  "version": "1.0.0-next.26",
   "license": "MIT",
   "type": "commonjs",
   "main": "./src/index.js",
@@ -9,6 +9,7 @@
     "@angular/core": ">=21.0.0",
     "@nx/devkit": ">=21.0.0",
     "@typescript-eslint/eslint-plugin": ">=8.0.0",
+    "@typescript-eslint/parser": ">=8.0.0",
     "eslint": ">=9.0.0",
     "typescript": ">=5.9.0"
   },

package/src/configs/recommended.js

@@ -9,12 +9,7 @@
  */
 const recommendedTs = {
   files: ['**/*.ts'],
-  plugins: {
-    // The plugin itself is injected by the caller (see index.js)
-  },
   rules: {
-    // ── TypeScript ──────────────────────────────────────────────────────────
-
     // No interface — use type (owned by ethlete/consistent-type-definitions)
     '@typescript-eslint/consistent-type-definitions': 'off',
 
@@ -36,8 +31,6 @@ const recommendedTs = {
       },
     ],
 
-    // ── Naming & formatting ─────────────────────────────────────────────────
-
     // No var
     'no-var': 'error',
 
@@ -53,7 +46,7 @@ const recommendedTs = {
     // Max two function parameters
     'max-params': ['error', 2],
 
-    // No _ or # prefixes; enforce camelCase / PascalCase / UPPER_CASE
+    // No # or trailing _ (leading _ only on variables, parameters, properties, methods); enforce camelCase / PascalCase / UPPER_CASE
     '@typescript-eslint/naming-convention': [
       'error',
       {
@@ -103,8 +96,6 @@ const recommendedTs = {
       },
     ],
 
-    // ── Banned syntax ───────────────────────────────────────────────────────
-
     'no-restricted-syntax': [
       'error',
       // enum / const enum is owned by ethlete/no-enum, so a lib can keep it on while it works
@@ -188,8 +179,6 @@ const recommendedTs = {
       },
     ],
 
-    // ── Native DOM globals ──────────────────────────────────────────────────
-
     // No direct document/window access — use inject(DOCUMENT) / inject(WINDOW) instead
     'no-restricted-globals': [
       'error',
@@ -203,8 +192,6 @@ const recommendedTs = {
       },
     ],
 
-    // ── Custom plugin rules ─────────────────────────────────────────────────
-
     // No inject(X).member chaining — assign to a const first
     'ethlete/no-inject-chain': 'error',
 
@@ -357,8 +344,6 @@ const recommendedTs = {
     // Angular language service completions for the rest of the file
     'ethlete/no-template-literal-before-inline-template': 'error',
 
-    // ── Angular components ──────────────────────────────────────────────────
-
     // Require ChangeDetectionStrategy.OnPush on Angular <= 21, where it is opt-in
     // (version-aware: inert on Angular 22+, where OnPush is the default).
     'ethlete/require-on-push-change-detection': 'error',
@@ -429,6 +414,12 @@ const recommendedTemplate = {
     '@angular-eslint/template/no-any': 'error',
     // Prefer plain attribute over unnecessary property binding for static strings: etIcon="foo" not [etIcon]="'foo'"
     '@angular-eslint/template/prefer-static-string-properties': 'error',
+    // Merged with the rule's own allowList (aria-label, title, innerText, ...), not replacing it.
+    // The et-* hosts render their own content and accessible name.
+    '@angular-eslint/template/elements-content': [
+      'error',
+      { allowList: ['aria-labelledby', 'et-match-card', 'et-match-participant'] },
+    ],
     // Prefer plain attribute over unnecessary property binding for static booleans: isReadonly not [isReadonly]="true"
     // (warn + suggestion-only: the rewrite is only safe when the input has a booleanAttribute transform,
     // which a template rule cannot verify)

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

@@ -9,7 +9,7 @@ const { getAngularDecoratorName } = require('./internals/import-resolution');
 /** @typedef {import('estree').Property & TNodeWithRange} TPropertyNode */
 /** @typedef {import('estree').SpreadElement & TNodeWithRange} TSpreadElementNode */
 /** @typedef {import('estree').ObjectExpression & TNodeWithRange & { properties: Array<TPropertyNode | TSpreadElementNode> }} TObjectExpressionNode */
-/** @typedef {{ hasComma: boolean; originalIndex: number; orderIndex: number; property: TPropertyNode; segmentText: string }} TPropertyEntry */
+/** @typedef {{ endsWithLineComment: boolean; hasComma: boolean; trailingText: string; originalIndex: number; orderIndex: number; property: TPropertyNode; segmentText: string }} TPropertyEntry */
 
 /** @type {Record<TDecoratorName, TDecoratorConfig>} */
 const DECORATOR_CONFIG = {
@@ -88,6 +88,7 @@ const angularDecoratorPropertyOrder = {
     type: 'layout',
     docs: {
       description: 'Require a consistent property order in Angular @Component and @Directive metadata objects.',
+      recommended: true,
     },
     fixable: 'code',
     messages: {
@@ -142,14 +143,25 @@ const angularDecoratorPropertyOrder = {
             const segmentEnd = hasComma && tokenAfter ? tokenAfter.range[0] : propertyNode.range[1];
             const segmentText = sourceCode.text.slice(segmentStart, segmentEnd);
 
+            let trailingText = '';
+            let endsWithLineComment = false;
+
             if (hasComma && tokenAfter) {
-              segmentStart = tokenAfter.range[1];
+              const sameLineComments = sourceCode
+                .getCommentsAfter(tokenAfter)
+                .filter((comment) => comment.loc?.start.line === tokenAfter.loc.end.line);
+              const lastComment = sameLineComments[sameLineComments.length - 1];
+              segmentStart = lastComment?.range ? lastComment.range[1] : tokenAfter.range[1];
+              trailingText = sourceCode.text.slice(tokenAfter.range[1], segmentStart);
+              endsWithLineComment = lastComment?.type === 'Line';
             } else {
               segmentStart = propertyNode.range[1];
             }
 
             return {
+              endsWithLineComment,
               hasComma,
+              trailingText,
               originalIndex,
               orderIndex,
               property: propertyNode,
@@ -188,11 +200,16 @@ const angularDecoratorPropertyOrder = {
           fix(fixer) {
             const reorderedBody =
               sortedEntries
-                .map(
-                  (entry, index) =>
-                    `${entry.segmentText}${index < sortedEntries.length - 1 || trailingComma ? ',' : ''}`,
-                )
-                .join('') + suffix;
+                .map((entry, index) => {
+                  const needsComma = index < sortedEntries.length - 1 || trailingComma || entry.trailingText !== '';
+                  const previous = sortedEntries[index - 1];
+                  const lead = previous?.endsWithLineComment && !entry.segmentText.startsWith('\n') ? '\n' : '';
+
+                  return `${lead}${entry.segmentText}${needsComma ? ',' : ''}${entry.trailingText}`;
+                })
+                .join('') +
+              (sortedEntries.at(-1)?.endsWithLineComment && !suffix.startsWith('\n') ? '\n' : '') +
+              suffix;
 
             return fixer.replaceTextRange([openingBrace.range[1], closingBrace.range[0]], reorderedBody);
           },

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

@@ -63,7 +63,7 @@ const getCallRootName = (node) => {
     return callee.name;
   }
 
-  if (callee.type === 'MemberExpression' && callee.object.type === 'Identifier') {
+  if (callee.type === 'MemberExpression' && !callee.computed && callee.object.type === 'Identifier') {
     return callee.object.name;
   }
 

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

@@ -30,6 +30,9 @@ const MEMBER_GROUP_INDEX = new Map(
   MEMBER_GROUP_ORDER.map(/** @param {TMemberGroup} group @param {number} index */ (group, index) => [group, index]),
 );
 
+/** @param {any} node */
+const isProperty = (node) => node.type === 'PropertyDefinition' || node.type === 'AccessorProperty';
+
 /**
  * @param {any} key
  */
@@ -95,7 +98,7 @@ const getAngularCallName = (sourceCode, value) => {
  * @param {Set<string>} apiNames
  */
 const isPropertyInitializedWith = (sourceCode, node, apiNames) => {
-  if (node.type !== 'PropertyDefinition') return false;
+  if (!isProperty(node)) return false;
 
   const apiName = getAngularCallName(sourceCode, node.value);
   return apiName !== null && apiNames.has(apiName);
@@ -108,7 +111,7 @@ const INJECT_HELPER_NAME_PATTERN = /^inject[A-Z]/;
  * @param {any} node
  */
 const isPropertyInitializedWithInject = (sourceCode, node) => {
-  if (node.type !== 'PropertyDefinition') return false;
+  if (!isProperty(node)) return false;
   if (getAngularCallName(sourceCode, node.value) === 'inject') return true;
 
   const rootName = getCallRootName(node.value);
@@ -123,7 +126,7 @@ const isPropertyInitializedWithInject = (sourceCode, node) => {
 const getMemberGroup = (sourceCode, node) => {
   if (node.static) return null;
 
-  if (node.type === 'PropertyDefinition') {
+  if (isProperty(node)) {
     if (isPropertyInitializedWithInject(sourceCode, node)) {
       return 'inject';
     }
@@ -194,7 +197,7 @@ const collectThisReferences = (node, references) => {
  * @param {any} node
  */
 const getInitializerDependencies = (node) => {
-  if (node.type !== 'PropertyDefinition' || !node.value) {
+  if (!isProperty(node) || !node.value) {
     return new Set();
   }
 
@@ -345,6 +348,42 @@ const getSegments = (sourceCode, classBodyNode) => {
   };
 };
 
+const ASI_HAZARD_TOKENS = new Set(['[', '(', '*', '`', 'in', 'instanceof']);
+
+/**
+ * @param {any} node
+ */
+const endsWithOwnBlock = (node) => node.type === 'StaticBlock' || (node.type === 'MethodDefinition' && node.value.body);
+
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} node
+ * @param {string} segmentText
+ * @param {any} nextNode
+ * @param {string} nextText
+ */
+const joinMovedSegment = (sourceCode, node, segmentText, nextNode, nextText) => {
+  const nextLeadingText = nextNode
+    ? nextText.slice(0, nextText.length - (getMemberEnd(sourceCode, nextNode) - nextNode.range[0]))
+    : nextText;
+  const nextStartsOnNewLine = nextLeadingText.includes('\n');
+  const lastToken = sourceCode.getLastToken(node);
+  const needsSemicolon =
+    lastToken?.value !== ';' &&
+    !endsWithOwnBlock(node) &&
+    nextNode &&
+    (!nextStartsOnNewLine || ASI_HAZARD_TOKENS.has(sourceCode.getFirstToken(nextNode)?.value ?? ''));
+
+  const memberEnd = getMemberEnd(sourceCode, node);
+  const nodeEnd = segmentText.length - (memberEnd - node.range[1]);
+  const withSemicolon = needsSemicolon ? `${segmentText.slice(0, nodeEnd)};${segmentText.slice(nodeEnd)}` : segmentText;
+  const endsWithLineComment = sourceCode
+    .getCommentsAfter(node)
+    .some((comment) => comment.type === 'Line' && comment.range?.[1] === memberEnd);
+
+  return endsWithLineComment && !nextStartsOnNewLine ? `${withSemicolon}\n` : withSemicolon;
+};
+
 /**
  * @param {import('eslint').SourceCode} sourceCode
  * @param {any} classBodyNode
@@ -373,11 +412,24 @@ const buildClassOrderFix = (sourceCode, classBodyNode, members) => {
   const rankedIndexes = new Set(members.map((member) => member.originalIndex));
   let nextSortedMember = 0;
 
+  const order = segmentTexts.map((_, index) =>
+    rankedIndexes.has(index) ? sortedMembers[nextSortedMember++].originalIndex : index,
+  );
+
   const reorderedBody =
-    segmentTexts
-      .map((segmentText, index) =>
-        rankedIndexes.has(index) ? segmentTexts[sortedMembers[nextSortedMember++].originalIndex] : segmentText,
-      )
+    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,
+        );
+      })
       .join('') + suffix;
 
   return (/** @type {import('eslint').Rule.RuleFixer} */ fixer) =>

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

@@ -10,6 +10,8 @@
  *   loadComponent: () => import('./items-list-view/items-list-view.component').then((m) => m.ItemsListViewComponent)
  */
 
+const VIEW_PATH = /-view(?![\w-])/;
+
 /** @type {import('eslint').Rule.RuleModule} */
 const enforceRoutingViewNaming = {
   meta: {
@@ -17,6 +19,7 @@ const enforceRoutingViewNaming = {
     docs: {
       description:
         'Routing components must import from a path containing "-view" and use a class name ending in "ViewComponent".',
+      recommended: true,
     },
     messages: {
       pathMustContainView: 'Routing import path must contain "-view". Got: "{{path}}".',
@@ -25,48 +28,56 @@ const enforceRoutingViewNaming = {
     schema: [],
   },
   create(context) {
+    /** @param {any} importExpr */
+    const checkImportPath = (importExpr) => {
+      if (!importExpr || importExpr.type !== 'ImportExpression') return;
+
+      const source = importExpr.source;
+      if (source && source.type === 'Literal' && typeof source.value === 'string' && !VIEW_PATH.test(source.value)) {
+        context.report({
+          node: source,
+          messageId: 'pathMustContainView',
+          data: { path: source.value },
+        });
+      }
+    };
+
     return {
       Property(node) {
         const key = /** @type {any} */ (node).key;
         if (key.type !== 'Identifier' || key.name !== 'loadComponent') return;
 
-        // Must be an arrow function: () => import(...).then(m => m.XxxViewComponent)
         const arrow = /** @type {any} */ (node).value;
         if (!arrow || arrow.type !== 'ArrowFunctionExpression') return;
 
         const body = arrow.body;
-        if (!body || body.type !== 'CallExpression') return;
+        if (!body) return;
+
+        if (body.type === 'ImportExpression') {
+          checkImportPath(body);
+          return;
+        }
+
+        if (body.type !== 'CallExpression') return;
 
         const callee = body.callee;
         if (!callee || callee.type !== 'MemberExpression') return;
         if (callee.property.type !== 'Identifier' || callee.property.name !== 'then') return;
 
-        // Check the import path contains "-view"
-        const importExpr = callee.object;
-        if (importExpr && importExpr.type === 'ImportExpression') {
-          const source = importExpr.source;
-          if (source && source.type === 'Literal' && typeof source.value === 'string') {
-            if (!source.value.includes('-view')) {
-              context.report({
-                node: source,
-                messageId: 'pathMustContainView',
-                data: { path: source.value },
-              });
-            }
-          }
-        }
-
-        // Check the class name in .then(m => m.XxxViewComponent)
-        const args = body.arguments;
-        if (!args || args.length === 0) return;
+        checkImportPath(callee.object);
 
-        const callback = args[0];
+        const callback = body.arguments?.[0];
         if (!callback || callback.type !== 'ArrowFunctionExpression') return;
 
         const cbBody = callback.body;
-        if (!cbBody || cbBody.type !== 'MemberExpression') return;
+        const returned =
+          cbBody?.type === 'BlockStatement'
+            ? cbBody.body.find(/** @param {any} statement */ (statement) => statement.type === 'ReturnStatement')
+                ?.argument
+            : cbBody;
+        if (!returned || returned.type !== 'MemberExpression') return;
 
-        const prop = cbBody.property;
+        const prop = returned.property;
         if (!prop || prop.type !== 'Identifier') return;
 
         if (!prop.name.endsWith('ViewComponent')) {

package/src/rules/guard-return-newline.js

@@ -25,6 +25,7 @@ const rule = {
     type: 'layout',
     docs: {
       description: 'Require an empty line before a return in a multi-statement if-block (guard clause).',
+      recommended: true,
     },
     fixable: 'whitespace',
     schema: [],
@@ -37,18 +38,14 @@ const rule = {
       ReturnStatement(node) {
         const blockParent = node.parent;
 
-        // Must be directly inside a BlockStatement
         if (!blockParent || blockParent.type !== 'BlockStatement') return;
 
-        // The block's parent must be an IfStatement's consequent
         const ifStatement = blockParent.parent;
         if (!ifStatement || ifStatement.type !== 'IfStatement') return;
         if (ifStatement.consequent !== blockParent) return;
 
-        // Block must have more than one statement (multi-statement guard)
         if (blockParent.body.length <= 1) return;
 
-        // The return must be the last statement in the block
         if (blockParent.body[blockParent.body.length - 1] !== node) return;
 
         const prevStatement = blockParent.body[blockParent.body.length - 2];
@@ -56,11 +53,11 @@ const rule = {
         if (!node.loc || !prevStatement.loc) return;
 
         const prevEndLine = prevStatement.loc.end.line;
-        const returnStartLine = node.loc.start.line;
+        const sourceCode = context.sourceCode;
 
-        if (returnStartLine - prevEndLine >= 2) return;
+        const textBetween = sourceCode.text.slice(prevStatement.range[1], node.range[0]);
 
-        const sourceCode = context.sourceCode;
+        if (/\n[ \t]*\r?\n/.test(textBetween)) return;
 
         context.report({
           node,

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

@@ -92,6 +92,28 @@ const readFileIfExists = (filePath) => {
   return null;
 };
 
+/** @type {WeakMap<import('eslint').SourceCode, Map<string, string | null>>} */
+const TEMPLATE_TEXT_CACHE = new WeakMap();
+
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {string} templatePath
+ */
+const readTemplateText = (sourceCode, templatePath) => {
+  let templates = TEMPLATE_TEXT_CACHE.get(sourceCode);
+
+  if (!templates) {
+    templates = new Map();
+    TEMPLATE_TEXT_CACHE.set(sourceCode, templates);
+  }
+
+  if (!templates.has(templatePath)) {
+    templates.set(templatePath, readFileIfExists(templatePath));
+  }
+
+  return templates.get(templatePath) ?? null;
+};
+
 /**
  * @param {import('eslint').Rule.RuleContext} context
  */
@@ -183,7 +205,7 @@ const isReferencedFromTemplateOrHostMetadata = (memberName, metadata, context) =
 
     if (templateUrl && filename) {
       const templatePath = path.resolve(path.dirname(filename), templateUrl);
-      const templateText = readFileIfExists(templatePath);
+      const templateText = readTemplateText(context.sourceCode, templatePath);
       if (templateReferencesMember(memberName, templateText)) {
         return true;
       }
@@ -209,7 +231,7 @@ const isReferencedFromTemplateOrHostMetadata = (memberName, metadata, context) =
  * @param {any} node
  */
 const getMemberName = (node) => {
-  if (node.key?.type === 'Identifier') return node.key.name;
+  if (node.key?.type === 'Identifier' && !node.computed) return node.key.name;
   if (node.key?.type === 'Literal' && typeof node.key.value === 'string') return node.key.value;
 
   return null;