noBannedTypes

TypeScript and TSX

Summary

Rule available since: v1.0.0
Diagnostic Category: lint/complexity/noBannedTypes
This rule is recommended, which means is enabled by default.
This rule has a safe fix.
The default severity of this rule is warning.
Sources:
- Same as @typescript-eslint/ban-types

How to configure

1
{
2
  "linter": {
3
    "rules": {
4
      "complexity": {
5
        "noBannedTypes": "error"
6
      }
7
    }
8
  }
9
}

Description

Disallow primitive type aliases and misleading types.

Enforce consistent names for primitive types

Primitive types have aliases. For example, Number is an alias of number. The rule recommends the lowercase primitive type names.

Disallow the Function type

The Function type is loosely typed and is thus considered dangerous or harmful. Function is equivalent to the type (...rest: any[]) => any that uses the unsafe any type.

Disallow the misleading non-nullable type {}

In TypeScript, the type {} doesn’t represent an empty object. It represents any value except null and undefined. The following TypeScript example is perfectly valid:

1
const n: {} = 0

code-block.ts:1:10 lint/complexity/noBannedTypes ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ Don’t use ’{}’ as a type.
  
  > 1 │ const n: {} = 0
      │          ^^
    2 │ 
  
  ℹ Prefer explicitly define the object shape. ’{}’ means “any non-nullable value”.

To represent an empty object, you should use { [k: string]: never } or Record<string, never>.

To avoid any confusion, the rule forbids the use of the type {}, except in two situations:

In type constraints to restrict a generic type to non-nullable types:

1
function f<T extends {}>(x: T) {
2
    assert(x != null);
3
}

In a type intersection to narrow a type to its non-nullable equivalent type:

1
type NonNullableMyType = MyType & {};

In this last case, you can also use the NonNullable utility type:

1
type NonNullableMyType = NonNullable<MyType>;

Examples

Invalid

1
let foo: String = "bar";

code-block.ts:1:10 lint/complexity/noBannedTypes  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ Don’t use ‘String’ as a type.
  
  > 1 │ let foo: String = “bar”;
      │          ^^^^^^
    2 │ 
  
  ℹ Use lowercase primitives for consistency.
  
  ℹ Safe fix: Use ‘string’ instead
  
    1   │ - let·foo:·String·=·“bar”;
      1 │ + let·foo:·string·=·“bar”;
    2 2 │

1
let bool = true as Boolean;

code-block.ts:1:20 lint/complexity/noBannedTypes  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ Don’t use ‘Boolean’ as a type.
  
  > 1 │ let bool = true as Boolean;
      │                    ^^^^^^^
    2 │ 
  
  ℹ Use lowercase primitives for consistency.
  
  ℹ Safe fix: Use ‘boolean’ instead
  
    1   │ - let·bool·=·true·as·Boolean;
      1 │ + let·bool·=·true·as·boolean;
    2 2 │

1
let invalidTuple: [string, Boolean] = ["foo", false];

code-block.ts:1:28 lint/complexity/noBannedTypes  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ Don’t use ‘Boolean’ as a type.
  
  > 1 │ let invalidTuple: [string, Boolean] = [“foo”, false];
      │                            ^^^^^^^
    2 │ 
  
  ℹ Use lowercase primitives for consistency.
  
  ℹ Safe fix: Use ‘boolean’ instead
  
    1   │ - let·invalidTuple:·[string,·Boolean]·=·[“foo”,·false];
      1 │ + let·invalidTuple:·[string,·boolean]·=·[“foo”,·false];
    2 2 │

Valid

1
let foo: string = "bar";

1
let tuple: [boolean, string] = [false, "foo"];