Typescript: string literal union type from enum

Question

I'd like to get a string literal union from an enum.

For this enum…

enum Weekday {
    MONDAY = 'mon',
    TUESDAY = 'tue',
    WEDNESDAY = 'wed'
}

… I'd like to get this:

type WeekdayType = 'mon' | 'tue' | 'wed';

I tried typeof keyof Weekday but that resulted in 'MONDAY' | 'TUESDAY' | 'WEDNESDAY'. Feel like the solution might have to do with mapped types but I can't seem to wrap my head around it.

How do I do this?

@jcalz when people 'answer' in comments like you did, the answers cannot be edited by the community. It's a pity, as this question can now be solved, but people coming onto this question will first read your (then correct, now incorrect) comment and may be mislead as a result. — Steve Dodier-Lazaro
– Steve Dodier-Lazaro, Commented Aug 19, 2023 at 9:37

starball · Accepted Answer · 2022-12-24 20:54:19Z

244

See TS4.1 ANSWER:

type WeekdayType = `${Weekday}`;

PRE TS-4.1 ANSWER:

This can't be done programmatically... you're trying to convert the type Weekday, which is Weekday.MONDAY | Weekday.TUESDAY | Weekday.WEDNESDAY, to the type WeekdayType which is "mon" | "tue" | "wed". This conversion is a form of widening, since Weekday is a subtype of WeekdayType:

type WeekdayExtendsWeekdayType = 
  Weekday extends WeekdayType ? true : false
// type WeekdayExtendsWeekdayType = true

Unfortunately the compiler doesn't give you a handle to remove an "enum"-ness from the enum type and leave you with plain literal types.

So, workarounds? Maybe you don't actually need an enum, but can make do with an object whose property values are string literals:

const lit = <V extends keyof any>(v: V) => v;
const Weekday = {
  MONDAY: lit("mon"),
  TUESDAY: lit("tue"),
  WEDNESDAY: lit("wed")
}
type Weekday = (typeof Weekday)[keyof typeof Weekday],

If you inspect it, the value named Weekday behaves like an enum object:

console.log(Weekday.TUESDAY); // tue

while the type named Weekday behaves like the union of string values "mon" | "tue" | "wed" that you were calling WeekdayType:

const w: Weekday = "wed"; // okay
const x: Weekday = "xed"; // error

So in this workaround, there is no "enum"-ness, and therefore no need to distinguish the type Weekday from the type WeekdayType. It's a little different from an actual enum (which includes types like Weekday.MONDAY, which you'd have to represent as the cumbersome typeof Weekday.MONDAY or create a different type alias for it), but it might behave similarly enough to be useful. Does that work for you?

edited Dec 24, 2022 at 20:54

starball♦

59.5k52 gold badges312 silver badges1k bronze badges

answered Sep 19, 2018 at 1:26

jcalz

339k29 gold badges452 silver badges449 bronze badges

Sign up to request clarification or add additional context in comments.

6 Comments

just-boris Over a year ago

Update: since typescript 3.4, special lit function is no longer needed. You can use const assertions instead

hotell Over a year ago

curios question @jcalz. What does <V extends keyof any> do? it prevents widening any kind of string/number literal ? thanks!

Pablo K Over a year ago

is there a way to do the opposite? Get a string enum from a type that is a union of string literals?

jcalz Over a year ago

@Pablo I don't think so.

Touré Holder Over a year ago

type WeekdayType = `${Weekday}`; is wicked

|

blackgreen · Accepted Answer · 2024-10-09 12:07:43Z

76

TypeScript 4.1+:

As mentioned, this can be achieved by using Template Literal Types like so:

type WeekdayType = `${Weekday}`;

TypeScript 3.4+:

Following up on @jcalz answer and the comment from @just-boris, here's an example with const assertions:

const Weekday = {
  MONDAY: "mon",
  TUESDAY: "tue",
  WEDNESDAY: "wed",
} as const;

type Weekday = (typeof Weekday)[keyof typeof Weekday];

edited Oct 9, 2024 at 12:07

blackgreen♦

46.8k29 gold badges171 silver badges162 bronze badges

answered Dec 27, 2019 at 4:58

designcise

4,4001 gold badge22 silver badges19 bronze badges

1 Comment

Mina Luke Over a year ago

That should work but has a limitation. ``` type Weekday1 = (typeof Weekday)[keyof typeof Weekday]; type Weekday2 = ${Weekday}; const day1: Weekday1 = Weekday.MONDAY; => works const day2: Weekday2 = Weekday.MONDAY; => works const day3: Weekday1 = 'mon' => does not work const day4: Weekday2 = 'mon'; => works ```

coyotte508 · Accepted Answer · 2022-11-27 22:05:19Z

71

With Typescript 4.1, it can be done!

enum Weekday {
  MONDAY = 'mon',
  TUESDAY = 'tue',
  WEDNESDAY = 'wed'
}

type WeekdayType = `${Weekday}`;

And for number enums, thanks to @okku:

enum ThreeDigits {
  ZERO = 0,
  ONE = 1,
  TWO = 2
}

type ThreeDigitsType = `${ThreeDigits}` extends `${infer T extends number}` ? T : never;

edited Nov 27, 2022 at 22:05

answered Nov 23, 2020 at 10:31

coyotte508

9,8406 gold badges48 silver badges66 bronze badges

8 Comments

Nonoroazoro Over a year ago

An easier way to to this is: type WeekdayUnion = ${Weekday}; That's it!

Michael G Over a year ago

any luck getting this to compile with ts-node?

coyotte508 Over a year ago

@MichaelG yes, you just need to update your typescript version to 4.1 in your project's package.json in your dev dependencies

sandbox992 Over a year ago

Could someone provide documentation for this behaviour plz?!

Okku Over a year ago

It does work with number enums, with some extra work: type WeekdayType = ${Weekday}` extends ${infer T extends number} ? T : never;`

|

Developer Sabbir · Accepted Answer · 2024-07-29 06:32:58Z

2

Here is a simple way to do that.

Here the example of how to convert a Typescript enum to a union type

export enum PaymentSystemEnum {
  APPLE = 'APPLE',
  GOOGLE = 'GOOGLE'
}

And it’s pretty easy

type = `${PaymentSystemEnum}`; // "APPLE" | "GOOGLE"

Reference Link

answered Jul 29, 2024 at 6:32

Developer Sabbir

3843 silver badges11 bronze badges

1 Comment

wentris Over a year ago

this way of extraction union out of enum is brilliant.

Tamas Hegedus · Accepted Answer · 2023-11-22 10:10:21Z

Typescript 4.8+ has some new features that we can use here. It works with string enums, number enums, and mixed enums too.

Typescript Playground

export type EnumToPrimitiveUnion<T> = `${T & string}` | ParseNumber<`${T & number}`>;
type ParseNumber<T> = T extends `${infer U extends number}` ? U : never;

export function typeCastEnum<E>(value: EnumToPrimitiveUnion<E>): E {
  return value as E;
}

enum Enum1 {
  A = 'a',
  B = 'b',
  X = 5,
}
enum Enum2 {
  A = 'a',
  C = 'c',
  Y = 6,
}
enum Enum3 {
  A2 = 'a',
  B2 = 'b',
  X2 = 5,
}


type PrimitiveEnum1 = EnumToPrimitiveUnion<Enum1>; // 'a' | 'b' | 5
typeCastEnum<Enum1>(Enum2.A); // ok, 'a' fits
typeCastEnum<Enum1>('b'); // ok
typeCastEnum<Enum1>(5); // ok
typeCastEnum<Enum1>(Enum3.A2 as Enum3); // ok, all values of Enum3 fit

// @ts-expect-error
typeCastEnum<Enum1>(Enum2.C); // err, 'c' does not fit
// @ts-expect-error
typeCastEnum<Enum1>('c'); // err, 'c' does not fit
// @ts-expect-error
typeCastEnum<Enum1>(Enum2.A as Enum2); // err, some values of Enum2 do not fit
// @ts-expect-error
typeCastEnum<Enum1>(Enum2.Y); // err
// @ts-expect-error
typeCastEnum<Enum1>(99); // err
// @ts-expect-error
typeCastEnum<Enum1>('foo'); // err

Collectives™ on Stack Overflow

Typescript: string literal union type from enum

5 Answers 5

6 Comments

1 Comment

8 Comments

Here is a simple way to do that.

1 Comment

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

6 Comments

1 Comment

8 Comments

Here is a simple way to do that.

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related