Add UnionToEnum and TupleToEnum types and fix UnionToTuple output

[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} !

[som-sm]

Apologies, haven't been able to re-read this. I'll give it a read sometime next week.

[benzaria]

@som-sm, Hey 👋 just following up on this, you mentioned you’d review it next week, but I haven’t seen any updates yet.
No rush if you’re busy, I just wanted to check whether there’s anything else needed from my side to move this forward.

[benzaria]

@som-sm Could you please take some time to review this PR when you get a chance, so we can move it forward?

[Emiyaaaaa]

This type name and parameter make me confused, maybe it can be split to UnionToEnum and TupleToEnum? @sindresorhus @som-sm what do you think?

[som-sm]

This type name and parameter make me confused, maybe it can be split to UnionToEnum and TupleToEnum? @sindresorhus @som-sm what do you think?

@Emiyaaaaa Yeah, pretty valid point, if the type is UnionToEnum, it shouldn't accept tuples. I think it makes sense to split it to UnionToEnum and TupleToEnum.

[benzaria]

@som-sm I also have a suggestion, why not just call it ToEnum. It's straight forward and eliminates the need for 2 types.

[som-sm]

@som-sm I also have a suggestion, why not just call it ToEnum. It's straight forward and eliminates the need for 2 types.

Umm...no, ToEnum is quite vague, I think it's fine to split it into two types.