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

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 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.23",
   "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',
@@ -245,6 +242,9 @@ const recommendedTs = {
     // 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 +272,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 +297,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 +414,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,13 +59,15 @@ 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 { 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,
@@ -126,6 +128,7 @@ const plugin = {
     'no-cdk-import': noCdkImport,
     'no-legacy-query-import': noLegacyQueryImport,
     'no-async-await': noAsyncAwait,
+    'no-enum': noEnum,
   },
 };
 

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

@@ -249,6 +249,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 +264,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,6 +345,14 @@ const classConstantProperty = {
             continue;
           }
 
+          if (
+            !member.readonly &&
+            ((member.value.type === 'Literal' && member.value.value === null) ||
+              (member.value.type === 'Identifier' && member.value.name === 'undefined'))
+          ) {
+            continue;
+          }
+
           if (memberName === 'transform' && hasPipeDecorator(node.parent)) {
             continue;
           }

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');
           },
         });
       },

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

@@ -2,6 +2,7 @@
 'use strict';
 
 const { getMemberName, isReferencedFromTemplateOrHost } = require('./internals/angular-member-visibility');
+const { buildAccessibilityFix } = require('./internals/member-accessibility-fix');
 
 /**
  * @param {any} node
@@ -12,25 +13,6 @@ const isInjectCall = (node) => {
   return node.value.callee.type === 'Identifier' && node.value.callee.name === 'inject';
 };
 
-/**
- * @param {any} node
- * @param {import('eslint').SourceCode} sourceCode
- * @param {'private' | 'protected'} expectedAccessibility
- */
-const buildFix = (node, sourceCode, expectedAccessibility) => {
-  const keyToken = sourceCode.getFirstToken(node.key);
-  if (!keyToken) return null;
-
-  if (node.accessibility) {
-    const firstToken = sourceCode.getFirstToken(node);
-    if (!firstToken) return null;
-
-    return (fixer) => fixer.replaceText(firstToken, expectedAccessibility);
-  }
-
-  return (fixer) => fixer.insertTextBefore(keyToken, `${expectedAccessibility} `);
-};
-
 /** @type {import('eslint').Rule.RuleModule} */
 const injectMemberAccessibility = {
   meta: {
@@ -63,6 +45,7 @@ const injectMemberAccessibility = {
         if (!memberName) return;
 
         const isTemplateOrHostVisible = isReferencedFromTemplateOrHost(classNode, memberName, context);
+        const isAbstractClass = classNode.abstract === true;
 
         if (isTemplateOrHostVisible) {
           if (node.accessibility === 'protected' || node.accessibility === 'public') return;
@@ -71,7 +54,7 @@ const injectMemberAccessibility = {
             node,
             messageId: 'shouldBeProtected',
             data: { name: memberName },
-            fix: buildFix(node, sourceCode, 'protected'),
+            fix: buildAccessibilityFix(node, sourceCode, 'protected'),
           });
 
           return;
@@ -79,11 +62,24 @@ const injectMemberAccessibility = {
 
         if (node.accessibility === 'private' || node.accessibility === 'public') return;
 
+        if (isAbstractClass) {
+          if (node.accessibility === 'protected') return;
+
+          context.report({
+            node,
+            messageId: 'shouldBeProtected',
+            data: { name: memberName },
+            fix: buildAccessibilityFix(node, sourceCode, 'protected'),
+          });
+
+          return;
+        }
+
         context.report({
           node,
           messageId: 'shouldBePrivate',
           data: { name: memberName },
-          fix: buildFix(node, sourceCode, 'private'),
+          fix: buildAccessibilityFix(node, sourceCode, 'private'),
         });
       },
     };

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

@@ -69,10 +69,28 @@ const getReactiveIo = (node) => {
   const factory = getFactoryName(value.callee);
   if (!factory) return null;
 
+  if (!Object.hasOwn(IO_FACTORIES, factory)) return null;
   const kind = /** @type {Record<string, 'input' | 'model' | 'output'>} */ (IO_FACTORIES)[factory];
   if (!kind) return null;
 
-  return { kind, name: node.key.name, keyNode: node.key };
+  let name = node.key.name;
+  for (const argument of value.arguments) {
+    if (argument.type !== 'ObjectExpression') continue;
+
+    const aliasProperty = argument.properties.find(
+      (property) =>
+        property.type === 'Property' &&
+        !property.computed &&
+        ((property.key.type === 'Identifier' && property.key.name === 'alias') ||
+          (property.key.type === 'Literal' && property.key.value === 'alias')),
+    );
+    if (aliasProperty?.value.type === 'Literal' && typeof aliasProperty.value.value === 'string') {
+      name = aliasProperty.value.value;
+      break;
+    }
+  }
+
+  return { kind, name, keyNode: node.key };
 };
 
 module.exports = { getReactiveIo };

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

@@ -67,8 +67,8 @@ const getStringValue = (node) => {
   if (!node) return null;
   if (node.type === 'Literal' && typeof node.value === 'string') return node.value;
 
-  if (node.type === 'TemplateLiteral' && node.expressions.length === 0 && node.quasis.length === 1) {
-    return node.quasis[0].value.cooked || '';
+  if (node.type === 'TemplateLiteral') {
+    return node.quasis.map((quasi) => quasi.value.cooked ?? quasi.value.raw).join(' ');
   }
 
   return null;
@@ -111,9 +111,9 @@ const templateReferencesMember = (memberName, template) => {
 
   const escapedName = escapeRegExp(memberName);
   const patterns = [
-    new RegExp(`\\{\\{[\\s\\S]*?\\b${escapedName}\\b[\\s\\S]*?\\}\\}`, 'u'),
-    new RegExp(`@[a-zA-Z]+\\s*\\([\\s\\S]*?\\b${escapedName}\\b[\\s\\S]*?\\)`, 'u'),
-    new RegExp(`@let\\s+[a-zA-Z_$][\\w$]*\\s*=\\s*[\\s\\S]*?\\b${escapedName}\\b`, 'u'),
+    new RegExp(`\\{\\{[^{}]*\\b${escapedName}\\b[^{}]*\\}\\}`, 'u'),
+    new RegExp(`@[a-zA-Z]+(?:\\s+if)?\\s*\\([^)]*\\b${escapedName}\\b[^)]*\\)`, 'u'),
+    new RegExp(`@let\\s+[a-zA-Z_$][\\w$]*\\s*=\\s*[^;]*\\b${escapedName}\\b`, 'u'),
     new RegExp(`\\*[a-zA-Z0-9_\\-]+\\s*=\\s*"[^"]*\\b${escapedName}\\b[^"]*"`, 'u'),
     new RegExp(`\\*[a-zA-Z0-9_\\-]+\\s*=\\s*'[^']*\\b${escapedName}\\b[^']*'`, 'u'),
     new RegExp(`\\[[^\\]]+\\]\\s*=\\s*"[^"]*\\b${escapedName}\\b[^"]*"`, 'u'),

package/src/rules/internals/angular-metadata-fix.js

@@ -0,0 +1,22 @@
+// @ts-check
+'use strict';
+
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} metadata
+ * @param {any} property
+ */
+const getMetadataEntryRemovalRange = (sourceCode, metadata, property) => {
+  const entries = metadata.properties;
+  const index = entries.indexOf(property);
+  const openingBrace = sourceCode.getFirstToken(metadata);
+  const closingBrace = sourceCode.getLastToken(metadata);
+
+  if (!openingBrace || !closingBrace || index === -1) return property.range;
+  if (entries.length === 1) return [openingBrace.range[1], closingBrace.range[0]];
+  if (index < entries.length - 1) return [property.range[0], entries[index + 1].range[0]];
+
+  return [entries[index - 1].range[1], property.range[1]];
+};
+
+module.exports = { getMetadataEntryRemovalRange };

package/src/rules/internals/member-accessibility-fix.js

@@ -0,0 +1,26 @@
+// @ts-check
+'use strict';
+
+/**
+ * @param {any} node
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {'private' | 'protected' | 'public'} accessibility
+ */
+const buildAccessibilityFix = (node, sourceCode, accessibility) => {
+  const decoratorEnd = node.decorators?.at(-1)?.range[1] ?? node.range[0];
+  const tokens = sourceCode.getTokens(node);
+  const accessibilityToken = tokens.find(
+    (token) => token.range[0] >= decoratorEnd && token.value === node.accessibility,
+  );
+
+  if (accessibilityToken) {
+    return (fixer) => fixer.replaceText(accessibilityToken, accessibility);
+  }
+
+  const insertionToken = tokens.find((token) => token.range[0] >= decoratorEnd);
+  if (!insertionToken) return null;
+
+  return (fixer) => fixer.insertTextBefore(insertionToken, `${accessibility} `);
+};
+
+module.exports = { buildAccessibilityFix };

package/src/rules/no-angular-seo-services.js

@@ -18,9 +18,9 @@
  *   import { Title, Meta } from '@angular/platform-browser';
  *
  * ✅ Use the @ethlete/core SEO utilities:
- *   import { injectTitleBinding, injectMetaBinding } from '@ethlete/core';
- *   const titleBinding = injectTitleBinding();
- *   const metaBinding  = injectMetaBinding();
+ *   import { applyHeadTitleBinding, applyMetaBinding } from '@ethlete/core';
+ *   applyHeadTitleBinding(title);
+ *   applyMetaBinding(meta);
  */
 
 /** @type {import('eslint').Rule.RuleModule} */
@@ -32,12 +32,12 @@ const rule = {
     },
     schema: [],
     messages: {
-      noInjectTitle: "Do not inject Angular's Title service. Use injectTitleBinding() from '@ethlete/core' instead.",
-      noInjectMeta: "Do not inject Angular's Meta service. Use injectMetaBinding() from '@ethlete/core' instead.",
+      noInjectTitle: "Do not inject Angular's Title service. Use applyHeadTitleBinding() from '@ethlete/core' instead.",
+      noInjectMeta: "Do not inject Angular's Meta service. Use applyMetaBinding() from '@ethlete/core' instead.",
       noImportTitle:
-        "Do not import Title from '@angular/platform-browser'. Use injectTitleBinding() from '@ethlete/core' instead.",
+        "Do not import Title from '@angular/platform-browser'. Use applyHeadTitleBinding() from '@ethlete/core' instead.",
       noImportMeta:
-        "Do not import Meta from '@angular/platform-browser'. Use injectMetaBinding() from '@ethlete/core' instead.",
+        "Do not import Meta from '@angular/platform-browser'. Use applyMetaBinding() from '@ethlete/core' instead.",
     },
   },
   create(context) {

package/src/rules/no-direct-dom-manipulation.js

@@ -100,6 +100,23 @@ const noDirectDomManipulation = {
 
         const methodName = callee.property.name;
 
+        if (
+          methodName === 'setProperty' &&
+          callee.object.type === 'MemberExpression' &&
+          callee.object.property.type === 'Identifier' &&
+          callee.object.property.name === 'style'
+        ) {
+          context.report({
+            node,
+            messageId: 'domMutation',
+            data: {
+              method: methodName,
+              alternative: 'renderer.setStyle(el, prop, value, RendererStyleFlags2.DashCase)',
+            },
+          });
+          return;
+        }
+
         // ── classList.add / .remove / .toggle / .replace ─────────────────────
         if (
           callee.object.type === 'MemberExpression' &&

package/src/rules/no-effect-cleanup-return.js

@@ -147,15 +147,17 @@ const noEffectCleanupReturn = {
           return;
         }
 
-        // Only the mechanical shape is auto-fixed: a zero-parameter callback whose single `return` hands
-        // back a function literal. With an existing parameter, an early `return`, or a returned reference,
-        // the intent needs a human.
-        // The parameter list's `(` — the first one before the body, so this works for `() => {}` and
-        // `function () {}` alike (their first token differs).
         const openParen = sourceCode
           .getTokens(callback)
           .find((token) => token.value === '(' && token.range[1] <= callback.body.range[0]);
-        const fixable = callback.params.length === 0 && returns.length === 1 && cleanupReturns.length === 1;
+        const callbackScope = sourceCode.getScope(callback);
+        const hasOnCleanupBinding = callbackScope.variables.some((variable) => variable.name === 'onCleanup');
+        const fixable =
+          callback.params.length === 0 &&
+          returns.length === 1 &&
+          cleanupReturns.length === 1 &&
+          callback.body.body.at(-1) === cleanupReturns[0] &&
+          !hasOnCleanupBinding;
 
         for (const statement of cleanupReturns) {
           context.report({

package/src/rules/no-empty-angular-metadata-arrays.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getMetadataEntryRemovalRange } = require('./internals/angular-metadata-fix');
+
 /** @typedef {'Component' | 'Directive'} TDecoratorName */
 
 /**
@@ -28,24 +30,6 @@ const getDecoratorName = (node) => {
   return expression.type === 'Identifier' ? expression.name : null;
 };
 
-/**
- * @param {import('eslint').SourceCode} sourceCode
- * @param {any} metadata
- * @param {any} property
- */
-const getRemovalRange = (sourceCode, metadata, property) => {
-  const properties = metadata.properties.filter((entry) => entry.type === 'Property');
-  const propertyIndex = properties.indexOf(property);
-  const openingBrace = sourceCode.getFirstToken(metadata);
-  const closingBrace = sourceCode.getLastToken(metadata);
-
-  if (!openingBrace || !closingBrace) return property.range;
-  if (properties.length === 1) return [openingBrace.range[1], closingBrace.range[0]];
-  if (propertyIndex < properties.length - 1) return [property.range[0], properties[propertyIndex + 1].range[0]];
-
-  return [properties[propertyIndex - 1].range[1], property.range[1]];
-};
-
 const MESSAGE_IDS = {
   hostDirectives: 'noEmptyHostDirectives',
   imports: 'noEmptyImports',
@@ -92,7 +76,7 @@ const noEmptyAngularMetadataArrays = {
             node: property,
             messageId: MESSAGE_IDS[propertyName],
             fix(fixer) {
-              return fixer.replaceTextRange(getRemovalRange(sourceCode, metadata, property), '');
+              return fixer.replaceTextRange(getMetadataEntryRemovalRange(sourceCode, metadata, property), '');
             },
           });
         }

package/src/rules/no-enum.js

@@ -0,0 +1,115 @@
+// @ts-check
+'use strict';
+
+/**
+ * Disallow `enum` and `const enum` — use a const object plus a derived union type.
+ *
+ * An enum is the only TypeScript construct that emits runtime code from a type declaration, so it
+ * cannot be erased and it cannot be tree-shaken. Its members are nominal, so a plain string is not
+ * assignable to an enum-typed parameter even when the value matches. A `const enum` is worse: a
+ * transpile-only consumer (esbuild, SWC, Babel) has no cross-file type information, so it cannot
+ * inline the member and the build fails or emits a missing binding.
+ *
+ * A const object with `as const` plus a derived union gives the same dotted access, keeps the name
+ * usable in a type position, accepts a matching literal, and tree-shakes.
+ *
+ * BAD:
+ *   export enum MatchState {
+ *     Live = 'live',
+ *   }
+ *
+ * GOOD:
+ *   export const MatchState = {
+ *     Live: 'live',
+ *   } as const;
+ *
+ *   export type MatchState = (typeof MatchState)[keyof typeof MatchState];
+ *
+ * The fixer runs only on an enum whose members all have a string literal initializer. It widens a
+ * member used in a type position (`state: MatchState.Live`), which then needs `typeof`.
+ */
+
+/** typescript-eslint v8 nests members under a TSEnumBody; earlier versions put them on the declaration. */
+const membersOf = (node) => node.body?.members ?? node.members ?? [];
+
+const isStringLiteral = (node) => node?.type === 'Literal' && typeof node.value === 'string';
+
+/** Only a plain string enum converts to a const object without changing what a member holds. */
+const isFixable = (node) => {
+  if (node.declare) return false;
+
+  const members = membersOf(node);
+
+  if (!members.length) return false;
+
+  return members.every(
+    (member) => isStringLiteral(member.initializer) && (member.id.type === 'Identifier' || isStringLiteral(member.id)),
+  );
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noEnum = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow enum and const enum. Use a const object with `as const` plus a derived union type.',
+      recommended: true,
+    },
+    fixable: 'code',
+    messages: {
+      noEnum:
+        "No enums. '{{name}}' emits runtime code that cannot be tree-shaken, and its members are nominal. Use a const object with 'as const' plus a derived union type.",
+      noConstEnum:
+        "No 'const enum'. A transpile-only consumer (esbuild, SWC, Babel) cannot inline '{{name}}' and its build fails. Use a const object with 'as const' plus a derived union type.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const { sourceCode } = context;
+
+    const buildReplacement = (node, target) => {
+      const name = node.id.name;
+      const indent = ' '.repeat(target.loc.start.column);
+      const memberIndent = `${indent}  `;
+      const exported = target.type === 'ExportNamedDeclaration' ? 'export ' : '';
+
+      const lines = membersOf(node).flatMap((member) => {
+        const comments = sourceCode.getCommentsBefore(member).flatMap((comment) =>
+          sourceCode
+            .getText(comment)
+            .split('\n')
+            // A block comment's continuation lines carry one more space so the leading `*` stays aligned.
+            .map((line, index) => `${memberIndent}${index === 0 ? '' : ' '}${line.trim()}`),
+        );
+
+        const key = sourceCode.getText(member.id);
+        const value = sourceCode.getText(member.initializer);
+
+        return [...comments, `${memberIndent}${key}: ${value},`];
+      });
+
+      return [
+        `${exported}const ${name} = {`,
+        ...lines,
+        `${indent}} as const;`,
+        '',
+        `${indent}${exported}type ${name} = (typeof ${name})[keyof typeof ${name}];`,
+      ].join('\n');
+    };
+
+    return {
+      TSEnumDeclaration(node) {
+        const target = node.parent?.type === 'ExportNamedDeclaration' ? node.parent : node;
+
+        context.report({
+          node: node.id,
+          messageId: node.const ? 'noConstEnum' : 'noEnum',
+          data: { name: node.id.name },
+          fix: isFixable(node) ? (fixer) => fixer.replaceTextRange(target.range, buildReplacement(node, target)) : null,
+        });
+      },
+    };
+  },
+};
+
+module.exports = noEnum;

package/src/rules/no-leading-underscore-class-member.js

@@ -73,11 +73,18 @@ const noLeadingUnderscoreClassMember = {
         const frame = classStack.pop();
         if (!frame) return;
 
+        const targetNameCounts = new Map();
+        for (const oldName of frame.membersByName.keys()) {
+          const newName = getFixedName(oldName);
+          targetNameCounts.set(newName, (targetNameCounts.get(newName) ?? 0) + 1);
+        }
+
         for (const [oldName, memberNodes] of frame.membersByName) {
           const newName = getFixedName(oldName);
           const canFix =
             newName.length > 0 &&
             !frame.declaredNames.has(newName) &&
+            targetNameCounts.get(newName) === 1 &&
             memberNodes.every((memberNode) => memberNode.accessibility === 'private');
 
           for (const memberNode of memberNodes) {