Add UnionToEnum type

[benzaria]

Closes #1084

Add UnionToEnum<T, Numeric, Options> utility for converting a union/tuple into an Enum-like object.

• string, number, or symbol unions or tuples
• Numeric Enum values starting from configurable Index, default: 1

Example:

import type {UnionToEnum} from 'type-fest';

type E1 = UnionToEnum<'A' | 'B' | 'C'>;
//=> { A: 'A'; B: 'B'; C: 'C' }

type E2 = UnionToEnum<'X' | 'Y' | 'Z', {numeric: true}>;
//=> { X: 1; Y: 2; Z: 3 }

type E3 = UnionToEnum<['Play', 'Pause', 'Stop'], {numeric: true; startIndex: 3}>;
//=> { Play: 3; Pause: 4; Stop: 5 }

type E4 = UnionToEnum<['some_key', 'another_key']>;
//=> { 'some_key': 'some_key'; 'another_key': 'another_key' }

type E5 = UnionToEnum<never>;
//=> {}

[benzaria]

@som-sm @sindresorhus Should CamelCase be true by default ?

[sindresorhus]

This type is doing too much. It should not do case transformation. That would be a task for a separate type. It should purely transform union to enum.

[benzaria]

This type is doing too much. It should not do case transformation. That would be a task for a separate type. It should purely transform union to enum.

fair enough i will remove case transformation.

[sindresorhus]

I don't think it should do startingIndex either. It's too limiting and could be done by a separate type too.

[benzaria]

I don't think it should do startingIndex either. It's too limiting and could be done by a separate type too.

Should I keep the starting index 1 or 0 ?

[sindresorhus]

Hmm, didn't think of that. Maybe we do indeed need the startIndex.

[benzaria]

Hmm, didn't think of that. Maybe we do indeed need the startIndex.

True, diff users may want diff index for there enum.

[benzaria]

@sindresorhus @som-sm Ready !

[som-sm]

What should be the behaviour in cases where UnionToEnum returns an index signature?

For example, currently invalid index signatures are returned in cases like these:

type T1 = UnionToEnum<string | number>;
// {readonly [x: string]: string; readonly [x: number]: number}

type T2 = UnionToEnum<[string, 'foo'], true>;
// {readonly [x: string]: 1; readonly foo: 2}

Maybe we should skip all non-literals?

[benzaria]

What should be the behaviour in cases where UnionToEnum returns an index signature?

Should also skip foo${string} !