强制使用泛型类型的值的类型安全

Question

How can i use generics in a way to enforce the type of a value to be of a specific kind?

// An example array
const testArr = [
  {
    id: 3,
    name: 'Spaghetto', // NOTE: Type 'string' here
    shouldNotWork: 3.14, // NOTE: Type 'number' here
  },
  {
    id: 5,
    name: 'Bread',
    shouldNotWork: 3.14,
  },
];

This is what i tried to be my mapping function, but i have to append as V2 to make TS not complain :/

type Mapping<T, U> = (val: T, i: number, arr: T[]) => U;

interface Option<T> {
  value: T;
  label: string; // <- NOTE: Type string is required
}

const typeToOption = <
  T,
  K1 extends keyof T,
  K2 extends keyof T,
  V2 extends T[K2] & string // <- NOTE: 'string' union here to match
>(
  valueK: K1,
  labelK: K2,
): Mapping<T, Option<T[K1]>> => (item: T): Option<T[K1]> => ({
  value: item[valueK],
  label: item[labelK] as V2,
});

I want TS to allow me this

const result = testArr.map(typeToOption('id', 'name'));

...but not this one

const result = testArr.map(typeToOption('id', 'shouldNotWork'));

How do i make TS complain about the latter?

Answer 1

I think you want to type typeToOption() like this:

const typeToOption = <
  T extends Record<K2, string>,
  K1 extends keyof T,
  K2 extends keyof T,
>(
  valueK: K1,
  labelK: K2,
): Mapping<T, Option<T[K1]>> => (item: T): Option<T[K1]> => ({
  value: item[valueK],
  label: item[labelK],
});

TypeScript lets you do some amount "circular" type constraints in generic parameters. So in this case, instead of specifying V2 at all (since it wasn't doing any work), we just require that T extends Record<K2, string> , which means that the type T must have a string valued property at the key K2 . This is enough to give you the behavior you're asking for:

const result = testArr.map(typeToOption('id', 'name')); // okay

const result = testArr.map(typeToOption('id', 'shouldNotWork')); // error
// [ts] Argument of type '"id"' is not assignable to 
// parameter of type '"shouldNotWork"'.

Although the error is a bit bewildering, at least it's an error. (If it matters: the type inference failure causes funny things to happen. T falls back to Record<'shouldNotWork', string> , equivalent to {shouldNotWork: string} , and keyof T is only 'shouldNotWork' , and therefore K1 extends 'shouldNotWork'`. Oh well.)

Hope that helps; good luck!