I'm working on improving the defs for Rosie, which currently rely a lot on any and don't offer much in the way of safety. I'm a little stuck at the moment and could use some advice.
I'm trying to write a signature that expresses the following:
// this is invalid, but something like this is the goal
interface IFactory<T = any> {
attr<K extends keyof T, D extends keyof T>(name: K, dependencies: D[], generatorFunction: (value1?: D[0], value2?: D[1], value3?: D[2]), value4?: D[3] => T[K]): IFactory<T>;
}
An array of keys is given in the second argument. The values of those are passed in as arguments to the function in the same order provided. I want to avoid unnecessary type casts, so we should get this:
Factory.define<Person>('Person').attr('fullName', ['firstName', 'lastName', 'age'], (firstName, lastName, age) => {
// it knows that firstName is a string, lastName is a string, age is a number
if (age > 10) {
// this will error
return age;
}
return `${firstName} ${lastName};
});
The closest I can get is this:
attr<K extends keyof T, D extends keyof T>(name: K, dependencies: D[], generatorFunction: (value1: T[D], value2: T[D], value3: T[D], value4: T[D]) => T[K]): IFactory<T>;
That will type up to 4 dependent values, but calling it requires explicit casts and it doesn't set types in the correct order:
// it knows that each of the three arguments are string | number
existingDefinition.attr('fullName', ['firstName', 'lastName', 'age'], (firstName: string, lastName: string, age: number) => `${firstName} ${lastName}`);
This makes it possible for me to change the order of dependencies without it breaking, which is no good. It also doesn't give an error if I provide more arguments than dependent values. I'd like to find a way of expressing "generatorFunction has one argument for each element in dependencies, of type T[DependencyName]."
I hope this makes sense. Appreciate any help anyone can offer.
