Type backward referring in TypeScript

user_5919113 0
Viewed 114

I need help with type declaration that contains a backward referring and I'll explain:

Given an interface Car like that:

interface Car {
  name: string,
  engine: Engine,
  brand: Brand,
  ...
}

I need to create a type of the following structure:

[ 'engine', (engine1, engine2) => {...} ]

Where engine1 and engine2 will be the same type as Car['engine'] and without limitation of generality - I need an array of:

[(keyof T) as S, (s1: S, s2: S) => { ... }]

In words: an array that contains exactly two elements: the first - is a property of T and the second is a function that accepts arg1 and arg2 where their type is the same type as the type of T[the first item in the array]

Can someone help me to declare such a type?

typescript-generics typescript javascript
2 Answers

This will do:

type MyType<T extends object> = { [S in keyof T]: [S, (s1: T[S], s2: T[S]) => any] }[keyof T];

const e: MyType<Car> = ['engine', (e1: Engine, e2: Engine) => { }];

Explanation (due to request in comment):

Just break it apart. Consider type:

type MyType1<T extends object, S extends keyof T> = [S, (s1: T[S], s2: T[S]) => any];

This type seems pretty obvious. But has one disadvantage - you must type key name explicitly.

const e: MyType1<Car, 'engine'> = ['engine', (e1: Engine, e2: Engine) => { }];

So you make union of all MyType1 possibilities for each property key:

type MyType2<T extends object> = { [S in keyof T]: MyType1<T, S> }[keyof T];

The original type above was just these two steps in one ;).

user_10108680

There is maybe a better approach but this is what I have.

I can't see a way to do it with a "plain" type so my suggestion is to create a "factory" - basically a function to create this kind of array.

This gives more flexibility with creating types.

type Engine = {
  model: number;
}
type Brand = {
  name: string;
}

interface Car {
  name: string;
  engine: Engine;
  brand: Brand;
}

interface ArrayFactory<T> {
  <U extends keyof T>(prop: U): [U, (arg1: T[U], arg2: T[U]) => void];
}

const createArray: ArrayFactory<Car> = (prop) => [prop, (arg1, arg2) => console.log(arg1, arg2)];

const arr = createArray('engine');
console.log(arr[0] === 'engine1');
arr[1]({model: 1}, {model: 2})

playground

user_8631100
Related