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

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # 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
+
+- The `@angular-eslint/*` output rules moved from `recommendedTs` into a new `recommendedAngularTs` config, which `recommended` includes, so NestJS and other non-Angular projects can use `recommendedTs` without the `@angular-eslint` plugin.
+- `recommendedTs` now uses `ethlete/consistent-type-definitions` instead of `@typescript-eslint/consistent-type-definitions`, so `--fix` no longer turns an interface inside `declare module` or `declare global` (such as the theme-name registry the `@ethlete/core` generators emit) into a type alias that merges into nothing.
+- New `no-csp-unsafe` rule (error in `recommendedTs` and `recommendedTemplate`) flags style attributes, un-nonced `<script>`/`<style>` elements, `eval` and string timers that a strict CSP blocks.
+- `et update` turns the type aliases the old `consistent-type-definitions` fix left in `declare module` and `declare global` blocks back into interfaces, and renames the rule in `eslint-disable` directives.
+- `prefer-linked-signal` now also reports an `effect()` that only calls `.set()` behind an `if`/`else`.
+
+### Patch Changes
+
+- `ethlete/no-csp-unsafe` fixes a static template `style="…"` attribute. It rewrites `style="width: 40%; margin-top: 4px"` to `[style]="{ width: '40%', 'margin-top': '4px' }"`, which a strict CSP allows. A value with a quote, `url(`, `!important` or a comment stays a manual fix.
+
 ## 1.0.0-next.24
 
 ### Minor Changes

package/migrations.json

@@ -0,0 +1,12 @@
+{
+  "migrations": [
+    {
+      "name": "module-augmentation-interfaces",
+      "version": "1.0.0-next.25",
+      "kind": "auto",
+      "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,14 +1,25 @@
 {
   "name": "@ethlete/eslint-plugin",
-  "version": "1.0.0-next.24",
+  "version": "1.0.0-next.26",
   "license": "MIT",
   "type": "commonjs",
   "main": "./src/index.js",
   "peerDependencies": {
     "@angular-eslint/eslint-plugin-template": ">=21.0.0",
     "@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"
-  }
+  },
+  "peerDependenciesMeta": {
+    "@nx/devkit": {
+      "optional": true
+    }
+  },
+  "ethlete": {
+    "migrations": "./migrations.json"
+  },
+  "generators": "./src/generators/generators.json"
 }

package/src/configs/recommended.js

@@ -9,14 +9,9 @@
  */
 const recommendedTs = {
   files: ['**/*.ts'],
-  plugins: {
-    // The plugin itself is injected by the caller (see index.js)
-  },
   rules: {
-    // ── TypeScript ──────────────────────────────────────────────────────────
-
-    // No interface — use type
-    '@typescript-eslint/consistent-type-definitions': ['error', 'type'],
+    // No interface — use type (owned by ethlete/consistent-type-definitions)
+    '@typescript-eslint/consistent-type-definitions': 'off',
 
     // No any
     '@typescript-eslint/no-explicit-any': 'error',
@@ -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',
 
@@ -248,6 +235,9 @@ const recommendedTs = {
     // No enum / const enum — use a const object with `as const` plus a derived union type
     'ethlete/no-enum': 'error',
 
+    // No interface — use type; an interface augmenting a module or the global scope is exempt
+    'ethlete/consistent-type-definitions': 'error',
+
     // No .subscribe() inside effect() or computed()
     'ethlete/no-rxjs-in-effect': 'error',
 
@@ -311,6 +301,10 @@ const recommendedTs = {
     // — use getCookie / setCookie / hasCookie / deleteCookie from '@ethlete/core' instead
     'ethlete/no-document-cookie': 'error',
 
+    // No code a strict CSP (no 'unsafe-inline' / 'unsafe-eval') blocks: style attributes,
+    // un-nonced <script>/<style> elements, eval / new Function / string timers
+    'ethlete/no-csp-unsafe': 'error',
+
     // Injected providers must be private by default, and protected only when
     // referenced from an Angular template or host binding.
     'ethlete/inject-member-accessibility': 'error',
@@ -350,16 +344,6 @@ const recommendedTs = {
     // Angular language service completions for the rest of the file
     'ethlete/no-template-literal-before-inline-template': 'error',
 
-    // ── Angular outputs ─────────────────────────────────────────────────────
-
-    // No on-prefixed outputs (onSelectDate → selectDate)
-    '@angular-eslint/no-output-on-prefix': 'error',
-
-    // No outputs named after native DOM events (change, click, etc.)
-    '@angular-eslint/no-output-native': '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',
@@ -402,6 +386,23 @@ const recommendedTs = {
   },
 };
 
+/**
+ * `@angular-eslint/*` rules for TypeScript files in Angular projects; the base config must register
+ * the `@angular-eslint` plugin.
+ *
+ * @type {import('eslint').Linter.Config}
+ */
+const recommendedAngularTs = {
+  files: ['**/*.ts'],
+  rules: {
+    // No on-prefixed outputs (onSelectDate → selectDate)
+    '@angular-eslint/no-output-on-prefix': 'error',
+
+    // No outputs named after native DOM events (change, click, etc.)
+    '@angular-eslint/no-output-native': 'error',
+  },
+};
+
 /**
  * Flat config entries for Angular HTML template files.
  * @type {import('eslint').Linter.Config}
@@ -413,12 +414,20 @@ 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)
     'ethlete/prefer-static-boolean-properties': 'warn',
     // A form must handle its own submission
     'ethlete/require-form-submit': 'error',
+    // No static style attribute or [attr.style] binding - a strict CSP blocks both
+    'ethlete/no-csp-unsafe': 'error',
   },
 };
 
@@ -432,6 +441,7 @@ const recommendedSpec = {
     '@typescript-eslint/no-non-null-assertion': 'off',
     'no-restricted-globals': 'off',
     'ethlete/no-async-await': 'off',
+    'ethlete/no-csp-unsafe': 'off',
     'ethlete/no-direct-dom-manipulation': 'off',
     'ethlete/no-document-cookie': 'off',
     'ethlete/no-dom-query': 'off',
@@ -444,4 +454,4 @@ const recommendedSpec = {
   },
 };
 
-module.exports = { recommendedTs, recommendedTemplate, recommendedSpec };
+module.exports = { recommendedTs, recommendedAngularTs, recommendedTemplate, recommendedSpec };

package/src/generators/generators.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://json.schemastore.org/nx-generators",
+  "generators": {
+    "restore-module-augmentation-interfaces": {
+      "implementation": "./restore-module-augmentation-interfaces/migration",
+      "schema": "./restore-module-augmentation-interfaces/schema.json",
+      "description": "Turn type aliases in declare module / declare global blocks back into interfaces, and rename consistent-type-definitions eslint directives"
+    }
+  }
+}

package/src/generators/restore-module-augmentation-interfaces/migration.js

@@ -0,0 +1,50 @@
+// @ts-check
+'use strict';
+
+const { formatFiles, visitNotIgnoredFiles } = require('@nx/devkit');
+const { restoreModuleAugmentationInterfaces } = require('./restore-module-augmentation-interfaces');
+
+const SOURCE_FILE = /\.(?:[cm]?ts|tsx|[cm]?js|jsx)$/;
+
+/**
+ * @param {import('@nx/devkit').Tree} tree
+ * @param {{ skipFormat?: boolean }} schema
+ */
+const migrateModuleAugmentationInterfaces = async (tree, schema) => {
+  console.log('\n🔄 Restoring module augmentation interfaces...');
+
+  let filesChanged = 0;
+  let reviewCount = 0;
+
+  visitNotIgnoredFiles(tree, '', (filePath) => {
+    if (!SOURCE_FILE.test(filePath)) return;
+
+    const before = tree.read(filePath, 'utf-8');
+
+    if (!before) return;
+
+    const result = restoreModuleAugmentationInterfaces(filePath, before);
+
+    for (const entry of result.review) {
+      reviewCount++;
+      console.warn(
+        `   ⚠ ${filePath}:${entry.line}: type ${entry.name} in a module augmentation is not an object literal, so it was left alone. An augmentation only merges as an interface.`,
+      );
+    }
+
+    if (!result.changed) return;
+
+    tree.write(filePath, result.content);
+    filesChanged++;
+    console.log(`   ✓ ${filePath}`);
+  });
+
+  console.log(filesChanged === 0 ? '   Nothing to migrate.\n' : `\n✅ Migrated ${filesChanged} file(s).\n`);
+
+  if (reviewCount > 0) console.warn(`   Review ${reviewCount} type alias(es) in module augmentations manually.\n`);
+
+  if (!schema.skipFormat) await formatFiles(tree);
+};
+
+module.exports = migrateModuleAugmentationInterfaces;
+module.exports.default = migrateModuleAugmentationInterfaces;

package/src/generators/restore-module-augmentation-interfaces/restore-module-augmentation-interfaces.js

@@ -0,0 +1,103 @@
+// @ts-check
+'use strict';
+
+const ts = require('typescript');
+
+const OLD_RULE = '@typescript-eslint/consistent-type-definitions';
+const NEW_RULE = 'ethlete/consistent-type-definitions';
+
+const LINE_DIRECTIVE = /\/\/[ \t]*eslint-(?:disable|enable)(?:-next-line|-line)?\b[^\n]*/g;
+const BLOCK_DIRECTIVE = /\/\*[ \t]*eslint-(?:disable|enable)(?:-next-line|-line)?\b(?:(?!\*\/)[\s\S])*\*\//g;
+
+const AUGMENTATION = /\bdeclare\s+(?:module|global)\b/;
+
+const renameInDirective = (/** @type {string} */ directive) => directive.split(OLD_RULE).join(NEW_RULE);
+
+/** Renames `@typescript-eslint/consistent-type-definitions` in every eslint-disable/enable directive. */
+const renameDirectives = (/** @type {string} */ content) =>
+  content.replace(LINE_DIRECTIVE, renameInDirective).replace(BLOCK_DIRECTIVE, renameInDirective);
+
+const isAugmentation = (/** @type {ts.Statement} */ statement) =>
+  ts.isModuleDeclaration(statement) &&
+  (ts.isStringLiteral(statement.name) || (statement.flags & ts.NodeFlags.GlobalAugmentation) !== 0) &&
+  statement.body !== undefined &&
+  ts.isModuleBlock(statement.body);
+
+/**
+ * @param {readonly ts.Statement[]} statements
+ * @param {ts.TypeAliasDeclaration[]} found
+ */
+const collectAugmentationAliases = (statements, found) => {
+  for (const statement of statements) {
+    if (!isAugmentation(statement)) continue;
+
+    const body = /** @type {ts.ModuleBlock} */ (/** @type {ts.ModuleDeclaration} */ (statement).body);
+
+    for (const member of body.statements) {
+      if (ts.isTypeAliasDeclaration(member)) found.push(member);
+    }
+
+    collectAugmentationAliases(body.statements, found);
+  }
+
+  return found;
+};
+
+/**
+ * Turns every object-literal `type X = { … }` directly inside a `declare module '…'` or
+ * `declare global` block back into `interface X { … }`, and renames
+ * `@typescript-eslint/consistent-type-definitions` in eslint directives to
+ * `ethlete/consistent-type-definitions`. Aliases of any other shape are returned in `review`.
+ *
+ * @param {string} filePath
+ * @param {string} content
+ * @returns {{ content: string; changed: boolean; review: { name: string; line: number }[] }}
+ */
+const restoreModuleAugmentationInterfaces = (filePath, content) => {
+  if (!AUGMENTATION.test(content)) {
+    const renamed = renameDirectives(content);
+
+    return { content: renamed, changed: renamed !== content, review: [] };
+  }
+
+  const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const aliases = collectAugmentationAliases(sourceFile.statements, []);
+
+  /** @type {{ name: string; line: number }[]} */
+  const review = [];
+  /** @type {{ start: number; end: number; text: string }[]} */
+  const edits = [];
+
+  for (const alias of aliases) {
+    const name = alias.name.text;
+
+    if (!ts.isTypeLiteralNode(alias.type)) {
+      review.push({ name, line: sourceFile.getLineAndCharacterOfPosition(alias.getStart(sourceFile)).line + 1 });
+      continue;
+    }
+
+    const modifiers = (alias.modifiers ?? []).map((modifier) => `${modifier.getText(sourceFile)} `).join('');
+    const typeParameters = content
+      .slice(alias.name.end, alias.type.pos)
+      .replace(/\s*=\s*$/, '')
+      .trim();
+
+    edits.push({
+      start: alias.modifiers?.[0]?.getStart(sourceFile) ?? alias.getStart(sourceFile),
+      end: alias.end,
+      text: `${modifiers}interface ${name}${typeParameters} ${alias.type.getText(sourceFile)}`,
+    });
+  }
+
+  let next = content;
+
+  for (const edit of edits.sort((left, right) => right.start - left.start)) {
+    next = next.slice(0, edit.start) + edit.text + next.slice(edit.end);
+  }
+
+  next = renameDirectives(next);
+
+  return { content: next, changed: next !== content, review };
+};
+
+module.exports = { restoreModuleAugmentationInterfaces };

package/src/generators/restore-module-augmentation-interfaces/schema.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "restore-module-augmentation-interfaces",
+  "title": "Restore module augmentation interfaces",
+  "type": "object",
+  "properties": {
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip formatting files after migration",
+      "default": false
+    }
+  },
+  "required": []
+}

package/src/index.js

@@ -30,6 +30,7 @@ const noLegacyAngularDecorators = require('./rules/no-legacy-angular-decorators'
 const noAngularSeoServices = require('./rules/no-angular-seo-services');
 const preferCloneEqual = require('./rules/prefer-clone-equal');
 const noDocumentCookie = require('./rules/no-document-cookie');
+const noCspUnsafe = require('./rules/no-csp-unsafe');
 const injectMemberAccessibility = require('./rules/inject-member-accessibility');
 const noRedundantInternal = require('./rules/no-redundant-internal');
 const templateMemberAccessibility = require('./rules/template-member-accessibility');
@@ -60,8 +61,9 @@ 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 consistentTypeDefinitions = require('./rules/consistent-type-definitions');
 const takeUntilDestroyedLast = require('./rules/take-until-destroyed-last');
-const { recommendedTs, recommendedTemplate, recommendedSpec } = require('./configs/recommended');
+const { recommendedTs, recommendedAngularTs, recommendedTemplate, recommendedSpec } = require('./configs/recommended');
 const { version } = require('../package.json');
 
 /** @type {import('eslint').ESLint.Plugin} */
@@ -102,6 +104,7 @@ const plugin = {
     'no-angular-seo-services': noAngularSeoServices,
     'prefer-clone-equal': preferCloneEqual,
     'no-document-cookie': noDocumentCookie,
+    'no-csp-unsafe': noCspUnsafe,
     'inject-member-accessibility': injectMemberAccessibility,
     'no-redundant-internal': noRedundantInternal,
     'template-member-accessibility': templateMemberAccessibility,
@@ -131,6 +134,7 @@ const plugin = {
     'no-legacy-query-import': noLegacyQueryImport,
     'no-async-await': noAsyncAwait,
     'no-enum': noEnum,
+    'consistent-type-definitions': consistentTypeDefinitions,
   },
 };
 
@@ -150,6 +154,8 @@ const recommendedTemplateWithPlugin = {
 const configs = {
   /** TypeScript rules (merged into a files: ['**\/*.ts'] block) */
   recommendedTs: recommendedTsWithPlugin,
+  /** `@angular-eslint/*` rules for TypeScript files (files: ['**\/*.ts']) */
+  recommendedAngularTs,
   /** Angular template rules (merged into a files: ['**\/*.html'] block) */
   recommendedTemplate: recommendedTemplateWithPlugin,
   /** Relaxed rules for spec files (files: ['**\/*.spec.ts']) */
@@ -158,7 +164,7 @@ const configs = {
    * Both together as a flat array — the most common usage:
    *   export default [...baseConfig, ...ethlete.configs.recommended]
    */
-  recommended: [recommendedTsWithPlugin, recommendedTemplateWithPlugin, recommendedSpec],
+  recommended: [recommendedTsWithPlugin, recommendedAngularTs, recommendedTemplateWithPlugin, recommendedSpec],
 };
 
 const ethletePlugin = { ...plugin, configs };

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) =>