export interface IGUser {
biography: string;
id: string;
ig_id: string;
followers_count: number;
follows_count: number;
media_count: number;
name: string;
profile_picture_url: string;
shopping_product_tag_eligibility: boolean;
username: string;
website: string;
}
const values: keyof IGUser = ['biography', ''];
How can I implement that I can only allow one instance of biography in the array?
You can't do that with typing only, but you could run it through a function that strips out duplicates: Delete duplicate elements from an array
Well, it is possible but only to a certain amount of keys. At some point the calculation of that unique array literal type will become to expensice because it is dependent on the length of your Union Type (keyof IGUser). You'll get an "Type instantiation is excessively deep and possibly infinite" error.
Anyway, inspired by this answer by Mu Tsun Tsai on the question Unordered tuple type I came up with the following. Using a Mapped Type and Exclude you can ensure that all literals in your array are unique . You essentially compute all valid combination based on your initial object keys union. Note that this approach disallows any duplicate literals, not just "biography"
interface IGUser {
biography: string;
name: string;
username: string;
// id: string;
// ig_id: string;
// followers_count: number;
// follows_count: number;
// media_count: number;
// profile_picture_url: string;
// shopping_product_tag_eligibility: boolean;
// website: string;
}
type SingleBiographyKeyArray<T extends string, R extends any[] = []> = R | {
[K in T]: SingleBiographyKeyArray<Exclude<T, K>, [K, ...R]>
}[T];
let values: SingleBiographyKeyArray<keyof IGUser> = []; // valid
values = ["biography"] // valid
values = ["biography", "name", "username"] // valid
values = ["biography", "biography", "name"];
// ~~~ invalid
values = ["biography", "username", "name", "name"];
// ~~~ invalid
Given you have a specific set of allowed values, you may do it like https://tsplay.dev/NlXgrN
type ValidateUniqueArray<T, A extends T[]> =
| A extends [infer F, ...infer L]
? (L extends Exclude<T, F>[]
? [F, ...ValidateUniqueArray<Exclude<T, F>, L>]
: [F, Exclude<T, F>?]
) : [T?, ...unknown[]]
;
type ValidateCompleteUniqueArray<T, A extends any[]> =
| [T] extends [never]
? []
: A extends [infer F, ...infer L]
? (F extends T
? [F, ...ValidateCompleteUniqueArray<Exclude<T, F>, L>]
: [T, ...ValidateCompleteUniqueArray<T, L>]
) : [T]
;
type conforms<T, V> = T extends V ? T : V;
function uniqueArray<T>() {
return {
partial<A extends T[]>(a: conforms<A, ValidateUniqueArray<T, A>>): A {
return a as A;
},
complete<A extends T[]>(a: conforms<A, ValidateCompleteUniqueArray<T, A>>): A {
return a as A;
},
}
}
let a1 = uniqueArray<1 | 2 | 3 | 4>().partial([
1, 2, 3, 4 // ok
])
let a2 = uniqueArray<1 | 2 | 3 | 4>().partial([
1, 1 // Type '1' is not assignable to type '2 | 3 | 4'.(2322)
])
let a3 = uniqueArray<1 | 2 | 3 | 4>().partial([
1, 'foo' // Type 'string' is not assignable to type '2 | 1 | 3 | 4'.(2322)
])
let b1 = uniqueArray<1 | 2 | 3 | 4>().complete([
1, 2, 3, 4 // ok
])
let b2 = uniqueArray<1 | 2 | 3 | 4>().complete([
1, 2, 3, 1 // Type '1' is not assignable to type '4'.(2322)
])
let b3 = uniqueArray<1 | 2 | 3 | 4>().complete([
1, 2, 3, 'foo' // error
])
let b4 = uniqueArray<1 | 2 | 3 | 4>().complete([
1, 2, 3 // Argument of type '[1, 2, 3]' is not assignable to parameter of type '[1, 2, 3, 4]'.
])
