Optional element with literal type in tuple type

Question

I try to create a read-only tuple type with optional elements. The list can be of any length and contain any of the three elements 'a', 'b', and 'c'. They are Literal Types, not string type.

This is my solution by now, it seems to work. This method has a disadvantage. If I have 100 different literal types, I need to add an optional symbol ? after each element, which is very cumbersome

export interface FormAttributesConfig {
    list: readonly ['a'?, 'b'?, 'c'?];
}

const attr1: FormAttributesConfig = {
    list: ['a', 'b', 'c']
}
const attr2: FormAttributesConfig = {
    list: ['a', 'b']
}
const attr3: FormAttributesConfig = {
    list: []
}

TypeScript Playground

UPDATE:

I can use Partial utility types to make all literal types in tuple optional.

export interface FormAttributesConfig {
    list: Partial<readonly ['a', 'b', 'c']>
}

I want to know if there are any disadvantages in this way or a better way?

There is a disadvantage. this type `[undefined]` is allowed. Does order of elements in the tuple matters? — captain-yossarian from Ukraine, Sep 15 '21 at 07:38
@captain-yossarian Thanks for the reply. The `undefined` value should not be allowed. The order does not matter. — Lin Du, Sep 15 '21 at 07:40

captain-yossarian from Ukraine · Answer 1 · 2021-09-15T08:52:16.187


// credits goes to https://stackoverflow.com/questions/68252446/is-it-possible-to-generate-string-literal-combinations-with-template-literal-in#answer-68256789
type Permutations<T extends string, U extends string = T> =
    T extends any ? (T | `${T} ${Permutations<Exclude<U, T>>}`) : never;

type ToArray<T extends string, Cache extends string[] = []> =
    (T extends `${infer Head} ${infer Tail}`
        ? ToArray<Tail, [...Cache, Head]>
        : (T extends `${infer Head}`
            ? [...Cache, Head]
            : Cache
        )
    )

type Util<T extends string> = ToArray<Permutations<T>> | []


export interface FormAttributesConfig {
    list: Util<'a' | 'b' | 'c'>
}

const attr1: FormAttributesConfig = {
    list: ['a', 'b', 'c']
}

const attr2: FormAttributesConfig = {
    list: ['a', 'b']
}

const attr3: FormAttributesConfig = {
    list: [] // allowed
}

const attr4: FormAttributesConfig = {
    list: [undefined] // error
}

ToArray splits string by empty symbol, just like stirng.split(' ') does. It iterates recursively over the string and grabs first char

Permutations computes all possible permutations.

Please keep in mind, this util is not CPU friendly Playground

Optional element with literal type in tuple type

1 Answers1