prefer-literal-enum-member
Require all enum members to be literal values.
Extending "plugin:@typescript-eslint/strict"
in an ESLint configuration enables this rule.
TypeScript allows the value of an enum member to be many different kinds of valid JavaScript expressions. However, because enums create their own scope whereby each enum member becomes a variable in that scope, developers are often surprised at the resultant values. For example:
const imOutside = 2;
const b = 2;
enum Foo {
outer = imOutside,
a = 1,
b = a,
c = b,
// does c == Foo.b == Foo.c == 1?
// or does c == b == 2?
}
The answer is that
Foo.c
will be1
at runtime [TypeScript playground].
Therefore, it's often better to prevent unexpected results in code by requiring the use of literal values as enum members. This rule reports when an enum member is given a value that is not a literal.
module.exports = {
"rules": {
"@typescript-eslint/prefer-literal-enum-member": "error"
}
};
Try this rule in the playground ↗
Examples
- ❌ Incorrect
- ✅ Correct
const str = 'Test';
enum Invalid {
A = str, // Variable assignment
B = {}, // Object assignment
C = `A template literal string`, // Template literal
D = new Set(1, 2, 3), // Constructor in assignment
E = 2 + 2, // Expression assignment
}
Open in Playgroundenum Valid {
A,
B = 'TestStr', // A regular string
C = 4, // A number
D = null,
E = /some_regex/,
}
Open in PlaygroundOptions
This rule accepts the following options:
type Options = [
{
allowBitwiseExpressions?: boolean;
},
];
const defaultOptions: Options = [{ allowBitwiseExpressions: false }];
allowBitwiseExpressions
When set to true
will allow you to use bitwise expressions in enum initializer (default: false
).
Examples of code for the { "allowBitwiseExpressions": true }
option:
- ❌ Incorrect
- ✅ Correct
const x = 1;
enum Foo {
A = x << 0,
B = x >> 0,
C = x >>> 0,
D = x | 0,
E = x & 0,
F = x ^ 0,
G = ~x,
}
Open in Playgroundenum Foo {
A = 1 << 0,
B = 1 >> 0,
C = 1 >>> 0,
D = 1 | 0,
E = 1 & 0,
F = 1 ^ 0,
G = ~1,
}
Open in PlaygroundWhen Not To Use It
If you want use anything other than simple literals as an enum value, this rule might not be for you.