@aneuhold/eslint-config 3.0.0 → 3.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aneuhold/eslint-config",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Main ESLint Configuration for personal projects",
   "main": "./src/configs/ts-lib-config.ts",
   "packageManager": "pnpm@10.33.0",

package/src/rules/no-private-modifier/classReports.ts

@@ -30,9 +30,7 @@ export const collectClassReports = (frame: ClassFrame): ClassReports => {
     if (member.accessibility !== 'private') {
       continue;
     }
-
     if (member.type === AST_NODE_TYPES.MethodDefinition && member.kind === 'constructor') {
-      reports.push({ member, messageId: 'privateConstructor' });
       continue;
     }
 

package/src/rules/no-private-modifier/no-private-modifier.md

@@ -14,11 +14,14 @@ Every form of the `private` modifier on a class member is reported:
 
 - Instance and `static` fields, including `accessor` properties.
 - Instance and `static` methods, getters, and setters.
-- Constructors (`private constructor() {}`).
 
 `public` and `protected` members, and members with no modifier, are left alone —
 this rule is only concerned with replacing `private`.
 
+**Private constructors are allowed.** `private constructor() {}` has no `#`
+equivalent — a constructor cannot be a `#private` member — and restricting
+construction this way (e.g. to force a static factory) is a valid pattern.
+
 **Constructor parameter properties are allowed.** `constructor(private foo: T)`
 is a concise, readable shorthand that declares and assigns the field in one
 place, and `#private` has no equivalent. Flagging it would force the verbose
@@ -42,8 +45,6 @@ class Counter {
   private accessor label = '';
 
   private increment(): void {}
-
-  private constructor() {}
 }
 ```
 
@@ -56,6 +57,8 @@ class Counter {
   accessor #label = '';
 
   #increment(): void {}
+
+  private constructor() {}
 }
 
 class Service {

package/src/rules/no-private-modifier/no-private-modifier.test.ts

@@ -22,6 +22,8 @@ ruleTester.run('no-private-modifier', noPrivateModifier, {
     { code: `class Foo { accessor #x = 1; }` },
     { code: `class Foo { get #x(): number { return 1; } }` },
     { code: `class Foo { constructor(foo: string) {} }` },
+    // Private constructors are allowed (no `#` constructor exists).
+    { code: `class Foo { private constructor() {} }` },
     // Constructor parameter properties are allowed (no `#` shorthand exists).
     { code: `class Foo { constructor(private foo: string) {} }` },
     { code: `class Foo { constructor(private readonly foo: string) {} }` },
@@ -75,12 +77,6 @@ ruleTester.run('no-private-modifier', noPrivateModifier, {
       errors: [{ messageId: 'privateField' }, { messageId: 'privateMethod' }],
       output: `class Foo { #count = 0; #helper() { return this.#count; } }`,
     },
-    // Private constructor: reported, never fixed.
-    {
-      code: `class Foo { private constructor() {} }`,
-      errors: [{ messageId: 'privateConstructor' }],
-      output: null,
-    },
     // Possible cross-instance access (`other.id`) is ambiguous, so no fix.
     {
       code: `class Foo { private id = 1; eq(other: Foo): boolean { return this.id === other.id; } }`,

package/src/rules/no-private-modifier/no-private-modifier.ts

@@ -10,9 +10,9 @@ import { type ClassFrame, type ClassNode } from './types';
  * syntax rather than the TypeScript `private` accessibility modifier, and
  * autofixes the conversion — declaration plus `this.x` / `ClassName.x`
  * references — whenever it can do so safely. Covers instance and static fields,
- * methods (including accessors and getters/setters), and constructors.
- * Constructor parameter properties (`constructor(private foo)`) are
- * intentionally allowed, since the `#` form has no equivalent shorthand.
+ * and methods (including accessors and getters/setters). Private constructors
+ * and constructor parameter properties (`constructor(private foo)`) are
+ * intentionally allowed, since the `#` form has no equivalent.
  *
  * References are gathered as ESLint makes its single pass over the file: a stack
  * tracks the class currently being traversed, and a per-class counter tracks how
@@ -33,8 +33,6 @@ export const noPrivateModifier = createRule({
         'Use a `#private` field instead of the TypeScript `private` modifier (e.g. `#count` rather than `private count`).',
       privateMethod:
         'Use a `#private` method instead of the TypeScript `private` modifier (e.g. `#helper()` rather than `private helper()`).',
-      privateConstructor:
-        'A constructor cannot become a `#private` member; drop the `private` modifier (consider a static factory if construction must be restricted).',
     },
     schema: [],
   },

package/src/rules/no-private-modifier/types.ts

@@ -10,7 +10,7 @@ export type FixableMember =
   | TSESTree.MethodDefinition;
 
 /** A message this rule can report. */
-export type MessageId = 'privateField' | 'privateMethod' | 'privateConstructor';
+export type MessageId = 'privateField' | 'privateMethod';
 
 /** A member to convert, paired with the references that convert alongside it. */
 export type FixTarget = { member: FixableMember; refs: TSESTree.MemberExpression[] };