useExhaustiveSwitchCases (JavaScript)

Language JavaScript (and super languages)

Summary

Rule available since: v2.0.0
Diagnostic Category: lint/nursery/useExhaustiveSwitchCases
This rule has an unsafe fix.
The default severity of this rule is information.
This rule belongs to the following domains:
- types
Sources:
- Same as @typescript-eslint/switch-exhaustiveness-check

How to configure

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

Description

Require switch-case statements to be exhaustive.

When working with union types in TypeScript, it’s common to want to write a switch statement intended to contain a case for each possible variant. However, if the union type changes, it’s easy to forget to modify the cases to account for any new types.

By default, this rule reports when a switch statement over a value typed as a union of literals lacks a case for any of those literal types and does not have a default clause. Set requireExplicitCase to true to check for missing cases even when the switch has a default clause.

Examples

Invalid

1
type Day =
2
  | 'Monday'
3
  | 'Tuesday'
4
  | 'Wednesday'
5
  | 'Thursday'
6
  | 'Friday'
7
  | 'Saturday'
8
  | 'Sunday';
9

10
declare const day: Day;
11
let result = 0;
12

13
switch (day) {
14
  case 'Monday':
15
    result = 1;
16
    break;
17
}

/invalid.ts:13:1 lint/nursery/useExhaustiveSwitchCases  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ The switch statement is not exhaustive.
  
    11 │ let result = 0;
    12 │ 
  > 13 │ switch (day) {
       │ ^^^^^^^^^^^^^^
  > 14 │   case 'Monday':
  > 15 │     result = 1;
  > 16 │     break;
  > 17 │ }
       │ ^
    18 │ 
  
  ℹ Some variants of the union type are not handled here.
  
  ℹ This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
  
  ℹ These cases are missing:
  
  - "Tuesday"
  - "Wednesday"
  - "Thursday"
  - "Friday"
  - "Saturday"
  - "Sunday"
  
  ℹ Unsafe fix: Add the missing cases to the switch statement.
  
    14 14 │     case 'Monday':
    15 15 │       result = 1;
    16    │ - ····break;
       16 │ + ····break;
       17 │ + ··case·"Tuesday":·throw·new·Error("TODO:·Not·implemented·yet");
       18 │ + ··case·"Wednesday":·throw·new·Error("TODO:·Not·implemented·yet");
       19 │ + ··case·"Thursday":·throw·new·Error("TODO:·Not·implemented·yet");
       20 │ + ··case·"Friday":·throw·new·Error("TODO:·Not·implemented·yet");
       21 │ + ··case·"Saturday":·throw·new·Error("TODO:·Not·implemented·yet");
       22 │ + ··case·"Sunday":·throw·new·Error("TODO:·Not·implemented·yet");
    17 23 │   }
    18 24 │

Valid

1
type Day =
2
  | 'Monday'
3
  | 'Tuesday'
4
  | 'Wednesday'
5
  | 'Thursday'
6
  | 'Friday'
7
  | 'Saturday'
8
  | 'Sunday';
9

10
declare const day: Day;
11
let result = 0;
12

13
switch (day) {
14
  case 'Monday':
15
    result = 1;
16
    break;
17
  case 'Tuesday':
18
    result = 2;
19
    break;
20
  case 'Wednesday':
21
    result = 3;
22
    break;
23
  case 'Thursday':
24
    result = 4;
25
    break;
26
  case 'Friday':
27
    result = 5;
28
    break;
29
  case 'Saturday':
30
    result = 6;
31
    break;
32
  case 'Sunday':
33
    result = 7;
34
    break;
35
}

Options

requireExplicitCase

Default: false.

A default clause handles any value that does not match a case. By default, the rule accepts this as covering all remaining values in a union. This means that adding a value to the union will not produce a diagnostic if the switch has a default clause.

Set requireExplicitCase to true to require a case for each value in the union. You can still keep default as a fallback for unexpected values at runtime.

1
{
2
  "linter": {
3
    "rules": {
4
      "nursery": {
5
        "useExhaustiveSwitchCases": {
6
          "level": "on",
7
          "options": {
8
            "requireExplicitCase": true
9
          }
10
        }
11
      }
12
    }
13
  }
14
}

With this option enabled, the switch below passes because "A", "B", and "C" each have a case. The default clause stays as a runtime fallback. Removing case "C" would produce a diagnostic, even though the fallback would handle that value.

1
type Letter = "A" | "B" | "C";
2
declare const letter: Letter;
3
switch (letter) {
4
    case "A":
5
    case "B":
6
    case "C":
7
        break;
8
    default:
9
        throw new Error("Unexpected letter");
10
}