CODEWITHSUNDEEP
typescript
CodeAndCats
CodeAndCats

Reputation: 7965

String Union to string Array

I have a string union type like so:

type Suit = 'hearts' | 'diamonds' | 'spades' | 'clubs';

I want a type-safe way to get all the possible values that can be used in this string union. But because interfaces are largely a design-time construct, the best I can do is this:

export const ALL_SUITS = getAllStringUnionValues<Suit>({
    hearts: 0,
    diamonds: 0,
    spades: 0,
    clubs: 0
});

export function getAllStringUnionValues<TStringUnion extends string>(valuesAsKeys: { [K in TStringUnion]: 0 }): TStringUnion[] {
    const result = Object.getOwnPropertyNames(valuesAsKeys);
    return result as any;
}

This works okay, the function ensures I always pass an object where each key is an element in the string union and that every element is included, and returns a string array of all the elements. So if the string union ever changes, the call to this function will error at compile time if not also updated.

However the problem is the type signature for the constant ALL_SUITS is ('hearts' | 'diamonds' | 'spades' | 'clubs')[]. In other words, TypeScript thinks it is an array containing none or more of these values possibly with duplicates, rather than an array containing all the values just once, e.g. ['hearts', 'diamonds', 'spades', 'clubs'].

What I'd really like is a way for my generic getAllStringUnionValues function to specify that it returns ['hearts', 'diamonds', 'spades', 'clubs'].

How can I achieve this generically while being as DRY as possible?

Upvotes: 215

Views: 165572

Answers (8)

PaoloDiBello
PaoloDiBello

Reputation: 11

Transform a union type into a tuple type, ensuring each element in the tuple corresponds to a unique member of the union

It would be more ideal to create the filters directly from filterIconsData, simplifying the process. However, this approach might be more beneficial when we need to define the array explicitly or when we want to ensure the safety of an array of objects.

export const filters = {
  filter1: "filter1",
  filter2: "filter2",
} as const;

type FilterKeys = keyof typeof filters;

type IconNames = "icon1" | "icon2";

type FilterIcon<Key extends FilterKeys> = {
  icon: IconNames;
  text: string;
  filter: Key;
};

type FilterIconUnion = {
  [K in FilterKeys]: FilterIcon<K>;
}[FilterKeys];

type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
  k: infer I
) => void
  ? I
  : never;

type UnionToTuple<U> = UnionToIntersection<
  U extends any ? (u: U) => void : never
> extends (v: infer V) => void
  ? [...UnionToTuple<Exclude<U, V>>, V]
  : [];

type FilterIconData = UnionToTuple<FilterIconUnion>;

const filterIconsData: FilterIconData = [
  {
    filter: "filter1",
    icon: "icon1",
    text: "Text 1",
  },
]; // throws error because it should be an array of objects containing all the filters key contained in filters, so to not throw the error

const filterIconsData2: FilterIconData = [
  {
    filter: "filter1",
    icon: "icon1",
    text: "Text 1",
  },
  {
    filter: "filter2",
    icon: "icon2",
    text: "Text 2",
  }  
]; // doesn't throw error because it contains all the keys contained in filters for the filter property

Upvotes: 1

kzaw
kzaw

Reputation: 912

Similar but simplified solution based on https://stackoverflow.com/a/70694878/1287288 (@f v):

function stringUnionToArray<T extends string>() {
  return <U extends T[]>(...args: U & ([T] extends [U[number]] ? unknown : never)) => args;
}

const stringArray1 = stringUnionToArray<"a" | "b">()("a", "b"); // ok
// const stringArray2 = stringUnionToArray<"a" | "b">()("a", "b", "c"); // fail
// const stringArray3 = stringUnionToArray<"a" | "b">()("a"); // fail
// const stringArray4 = stringUnionToArray<"a" | "b">()(); // fail

There is a nice and clean solution if you can use TypeBox:

const FooSchema = Type.Object({
  foo: Type.String(),
  bar: Type.Boolean(),
  baz: Type.Number(),
});

type Foo = Static<typeof FooSchema>;

const FooKeysUnionSchema = Type.KeyOf(FooSchema);
const FooKeysTupleSchema = Type.Tuple(Type.Rest(FooKeysUnionSchema));
const fooKeys = Value.Create(FooKeysTupleSchema); // ["foo", "bar", "baz"]

// or just:
const fooKeys = Value.Create(Type.Tuple(Type.Rest(Type.KeyOf(FooSchema))));

Upvotes: 2

jcalz
jcalz

Reputation: 327774

Answer for TypeScript 3.4 and above

It is not really possible to convert a union to a tuple in TypeScript, at least not in a way that behaves well. Unions are intended to be unordered, and tuples are inherently ordered, so even if you can manage to do it, the resulting tuples can behave in unexpected ways. See this answer for a method that does indeed produce a tuple from a union, but with lots of caveats about how fragile it is. Also see microsoft/TypeScript#13298, a declined feature request for union-to-tuple conversion, for discussion and a canonical answer for why this is not supported.

However, depending on your use case, you might be able to invert the problem: specify the tuple type explicitly and derive the union from it. This is relatively straightforward.

Starting with TypeScript 3.4, you can use a const assertion to tell the compiler to infer the type of a tuple of literals as a tuple of literals, instead of as, say, string[]. It tends to infer the narrowest type possible for a value, including making everything readonly. So you can do this:

const ALL_SUITS = ['hearts', 'diamonds', 'spades', 'clubs'] as const;
type SuitTuple = typeof ALL_SUITS; // readonly ['hearts', 'diamonds', 'spades', 'clubs']
type Suit = SuitTuple[number];  // "hearts" | "diamonds" | "spades" | "clubs"

Playground link to code

Answer for TypeScript 3.0 to 3.3

It looks like, starting with TypeScript 3.0, it will be possible for TypeScript to automatically infer tuple types. Once that is released, the tuple() function you need can be succinctly written as:

export type Lit = string | number | boolean | undefined | null | void | {};
export const tuple = <T extends Lit[]>(...args: T) => args;

And then you can use it like this:

const ALL_SUITS = tuple('hearts', 'diamonds', 'spades', 'clubs');
type SuitTuple = typeof ALL_SUITS;
type Suit = SuitTuple[number];  // union type

Answer for TypeScript before 3.0

Since I posted this answer, I found a way to infer tuple types if you're willing to add a function to your library. Check out the function tuple() in tuple.ts.

Using it, you are able to write the following and not repeat yourself:

const ALL_SUITS = tuple('hearts', 'diamonds', 'spades', 'clubs');
type SuitTuple = typeof ALL_SUITS;
type Suit = SuitTuple[number];  // union type

Original Answer

The most straightforward way to get what you want is to specify the tuple type explicitly and derive the union from it, instead of trying to force TypeScript to do the reverse, which it doesn't know how to do. For example:

type SuitTuple = ['hearts', 'diamonds', 'spades', 'clubs'];
const ALL_SUITS: SuitTuple = ['hearts', 'diamonds', 'spades', 'clubs']; // extra/missing would warn you
type Suit = SuitTuple[number];  // union type

Note that you are still writing out the literals twice, once as types in SuitTuple and once as values in ALL_SUITS; you'll find there's no great way to avoid repeating yourself this way, since TypeScript cannot currently be told to infer tuples, and it will never generate the runtime array from the tuple type.

The advantage here is you don't require key enumeration of a dummy object at runtime. You can of course build types with the suits as keys if you still need them:

const symbols: {[K in Suit]: string} = {
  hearts: '♥', 
  diamonds: '♦', 
  spades: '♠', 
  clubs: '♣'
}

Upvotes: 347

f v
f v

Reputation: 523

Easy and right in the heart.

String Union to string Array - the proper decision!

type ValueOf<T> = T[keyof T];

type NonEmptyArray<T> = [T, ...T[]]

type MustInclude<T, U extends T[]> = [T] extends [ValueOf<U>] ? U : never;

function stringUnionToArray<T>() {
  return <U extends NonEmptyArray<T>>(...elements: MustInclude<T, U>) => elements;
}


/* USAGE */
type Variants = "error" | "success" | "info";

// This is what You want!! :)
let stringArray = stringUnionToArray<Variants>()("error", "success", "info");

Upvotes: 20

mooksel
mooksel

Reputation: 153

As @jcalz said, You can not build tuple type for union type because tuple is ordered, when union - not. But, You can build a new union of all possible tuple types that will contain all values of the input union.

Example:

type U2O<U extends string> = {
  [key in U]: U2O<Exclude<U, key>>;
}

type O2T<O extends {}> = {} extends O ? [] : {
  [key in keyof O]: [key, ...O2T<O[key]>];
}[keyof O]

type InputUnion = 'a' | 'b' | 'c'

type UnionOfPossibleTuples = O2T<U2O<InputUnion>>

// Now `UnionOfPossibleTuples` equals to ["a", "b", "c"] | ["a", "c", "b"] | ["b", "a", "c"] | ["b", "c", "a"] | ["c", "a", "b"] | ["c", "b", "a"]

Upvotes: 6

Zomono
Zomono

Reputation: 852

The accepted answer may not be sufficient if one wants to ensure that a given array matches all the elements of an existing union type.

Here is a solution that uses a function call to ensure that the provided array matches a given union at compile time:

type NoneEmptyArray = readonly any[] & {0: any}
type CompareUnionWithArray<P, Q extends NoneEmptyArray> = Exclude<P, Q[number]> extends never
    ? (Exclude<Q[number], P> extends never ? Q : ReadonlyArray<P>)
    : readonly [...Q, Exclude<P, Q[number]>]
export function assertTypeEquals<P, Q extends NoneEmptyArray>(test: CompareUnionWithArray<P, Q>): void {}

Test Example:
type Suit = 'hearts' | 'diamonds' | 'spades' | 'clubs'

const matchingArray = ['hearts', 'diamonds', 'spades', 'clubs'] as const
const emptyArray = [] as const
const unknownElements = ['hearts', 'diamonds', 'spades', 'clubs', 'UNKNOWN'] as const
const missingElements = ['hearts', 'diamonds', "clubs"] as const

assertTypeEquals<Suit, (typeof matchingArray)>(matchingArray) // no error
assertTypeEquals<Suit, (typeof emptyArray)>(missingElements) // fails because empty array is not allowed
assertTypeEquals<Suit, (typeof unknownElements)>(unknownElements) // fails with: Type '"UNKNOWN"' is not assignable to type 'Suit'.
assertTypeEquals<Suit, (typeof missingElements)>(missingElements) // fails with:
// Argument of type 'readonly ["hearts", "diamonds", "clubs"]' is not assignable to
// parameter of type 'readonly ["hearts", "diamonds", "clubs", "spades"]'.
// Source has 3 element(s) but target requires 4.

Update: Improved the code to not require a useless constant and to generate more informative error messages.

Upvotes: 1

Akxe
Akxe

Reputation: 11485

Method for transforming string union into a non-duplicating array

Using keyof we can transform union into an array of keys of an object. That can be reapplied into an array.

Playground link

type Diff<T, U> = T extends U ? never : T;

interface IEdiatblePartOfObject {
    name: string;
}

/**
 * At least one key must be present, 
 * otherwise anything would be assignable to `keys` object.
 */
interface IFullObject extends IEdiatblePartOfObject {
    potato: string;
}

type toRemove = Diff<keyof IFullObject, keyof IEdiatblePartOfObject>;

const keys: { [keys in toRemove]: any } = {
    potato: void 0,
};

const toRemove: toRemove[] = Object.keys(keys) as any;

This method will create some overhead but will error out, if someone adds new keys to IFullObject.

Bonus:

declare const safeData: IFullObject;
const originalValues: { [keys in toRemove]: IFullObject[toRemove] } = {
    potato: safeData.potato || '',
};

/**
 * This will contain user provided object,
 * while keeping original keys that are not alowed to be modified
 */
Object.assign(unsafeObject, originalValues);

Upvotes: 0

ggradnig
ggradnig

Reputation: 14159

Update for TypeScript 3.4:

There will be a more concise syntax coming with TypeScript 3.4 called "const contexts". It is already merged into master and should be available soon as seen in this PR.

This feature will make it possible to create an immutable (constant) tuple type / array by using the as const or <const> keywords. Because this array can't be modified, TypeScript can safely assume a narrow literal type ['a', 'b'] instead of a wider ('a' | 'b')[] or even string[] type and we can skip the call of a tuple() function.

To refer to your question

However the problem is the type signature for the constant ALL_SUITS is ('hearts' | 'diamonds' | 'spades' | 'clubs')[]. (... it should rather be) ['hearts', 'diamonds', 'spades', 'clubs']

With the new syntax, we are able to achieve exactly that:

const ALL_SUITS = <const> ['hearts', 'diamonds', 'spades', 'clubs'];  
// or 
const ALL_SUITS = ['hearts', 'diamonds', 'spades', 'clubs'] as const;

// type of ALL_SUITS is infererd to ['hearts', 'diamonds', 'spades', 'clubs']

With this immutable array, we can easily create the desired union type:

type Suits = typeof ALL_SUITS[number]

Upvotes: 40

Related Questions