extraneousClasses

Reports classes used as static namespaces.

✅ This rule is included in the ts logicalStrict presets.

Classes that contain only static members or only a constructor can be replaced with simpler constructs. Static-only classes are often used as namespaces, but in JavaScript and TypeScript, individual module exports serve this purpose better. Classes with only a constructor can typically be replaced with standalone functions.

Using classes as static namespaces has several drawbacks:

Wrapper classes add cognitive complexity without structural improvements
Contents are already organized by being in a module
IDEs provide better suggestions for module exports than static class properties
Static analysis tools can more easily detect unused exports in modules

class 
class Empty
Empty {}

class 
class OnlyConstructor
OnlyConstructor {
  constructor() {
    
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
@since ― v0.1.100
log("init");
  }
}

class 
class StaticUtils
StaticUtils {
  static 
StaticUtils.format(value: string): string
format(
value: string
value: string) {
    return 
value: string
value.
String.trim(): string
Removes the leading and trailing white space and line terminator characters from a string.
trim();
  }

  static 
StaticUtils.parse(value: string): any
parse(
value: string
value: string) {
    return 
var JSON: JSON
An intrinsic object that provides functions to convert JavaScript values to and from the JavaScript Object Notation (JSON) format.
JSON.
JSON.parse(text: string, reviver?: (this: any, key: string, value: any) => any): any
Converts a JavaScript Object Notation (JSON) string into an object.
@param ― text A valid JSON string.
@param ― reviver A function that transforms the results. This function is called for each member of the object.
If a member contains nested objects, the nested objects are transformed before the parent object is.
@throws ― {SyntaxError} If text is not valid JSON.
parse(
value: string
value);
  }
}

class 
class Constants
Constants {
  static readonly 
Constants.VERSION: "1.0.0"
VERSION = "1.0.0";
  static readonly 
Constants.MAX_SIZE: 100
MAX_SIZE = 100;
}

class 
class Example
Example {
  
Example.value: number
value = 42;
}

class 
class Example
Example {
  constructor(public 
Example.value: number
value: number) {}
}

export function 
function format(value: string): string
format(
value: string
value: string) {
  return 
value: string
value.
String.trim(): string
Removes the leading and trailing white space and line terminator characters from a string.
trim();
}

export function 
function parse(value: string): any
parse(
value: string
value: string) {
  return 
var JSON: JSON
An intrinsic object that provides functions to convert JavaScript values to and from the JavaScript Object Notation (JSON) format.
JSON.
JSON.parse(text: string, reviver?: (this: any, key: string, value: any) => any): any
Converts a JavaScript Object Notation (JSON) string into an object.
@param ― text A valid JSON string.
@param ― reviver A function that transforms the results. This function is called for each member of the object.
If a member contains nested objects, the nested objects are transformed before the parent object is.
@throws ― {SyntaxError} If text is not valid JSON.
parse(
value: string
value);
}

export const 
const VERSION: "1.0.0"
VERSION = "1.0.0";
export const 
const MAX_SIZE: 100
MAX_SIZE = 100;

class 
class Derived
Derived extends 
const Base: any
Base {
  static 
Derived.helper(): number
helper() {
    return 42;
  }
}

abstract class 
class Base
Base {
  abstract 
Base.getValue(): number
getValue(): number;
}

Options

`allowEmpty`

When set to true, allows empty classes with no members.

// Valid with { allowEmpty: true }
class 
class Empty
Empty {}

`allowConstructorOnly`

When set to true, allows classes that contain only a constructor.

// Valid with { allowConstructorOnly: true }
class 
class Example
Example {
  constructor() {
    
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
@since ― v0.1.100
log("init");
  }
}

`allowStaticOnly`

When set to true, allows classes that only contain static members.

// Valid with { allowStaticOnly: true }
class 
class Utils
Utils {
  static 
Utils.format(value: string): string
format(
value: string
value: string) {
    return 
value: string
value.
String.trim(): string
Removes the leading and trailing white space and line terminator characters from a string.
trim();
  }
}

`allowWithDecorator`

When set to true, allows any extraneous class that includes a decorator. This is useful for frameworks that use decorators to configure classes.

// Valid with { allowWithDecorator: true }
@
const Injectable: any
Injectable()
class 
class Service
Service {}

When Not To Use It

If your codebase uses frameworks that rely heavily on class decorators for configuration (such as Angular or NestJS), you may want to enable allowWithDecorator for consistency. Some legacy codebases may use classes as namespaces extensively, in which case migrating may not be practical.

Equivalents in Other Linters

ESLint: @typescript-eslint/no-extraneous-class
Oxlint: typescript/no-extraneous-class

Made with ❤️‍🔥 around the world by the Flint team and contributors.

extraneousClasses

Examples

Options

allowEmpty

allowConstructorOnly

allowStaticOnly