To simplify this situation, consider making the Command object generic, as demonstrated in your example:
type Command<T> = {
name: string,
input: T,
resolve({ input }: { input: T }): void
}
Although you will need to specify the generic type later on, it is advantageous if you want flexibility in calling the resolve() method with various inputs beyond just the default input property.
However, manual specification of the type argument is not mandatory. You can utilize generic helper functions to automatically infer it. For instance, using the following function:
const asCommand = <T,>(c: Command<T>) => c;
You can deduce the type argument for a specific command:
const command = asCommand({
name: "setscore",
input: [["b", "blue", "r", "red"], Number()] as const,
resolve({ input }) {
const [teamName, score] = input
// const teamName: readonly ["b", "blue", "r", "red"]
// const score: number
}
});
//const command: Command<readonly [readonly ["b", "blue", "r", "red"], number]>
In this code snippet, the compiler recognizes T as
readonly [readonly ["b", "blue", "r", "red"], number]
thanks to the
const assertion placed on
input.
Additionally, by employing another helper function:
const asCommandArray = <T extends any[]>(
...arr: { [I in keyof T]: Command<T[I]> }) => arr;
You can configure an array of commands with distinct type arguments using inference from mapped array types:
const arr = asCommandArray(
{ name: "x", input: "abc", resolve({ input }) { console.log(input.toUpperCase()) } },
{ name: "y", input: 123, resolve({ input }) { console.log(input.toFixed()) } }
)
// const arr: [Command<string>, Command<number>]
This implementation should align with your requirements.
The strategies mentioned above assume that the type of input is significant, necessitating tracking the type argument T for each command object, especially if you plan to invoke command.resolve() with diverse inputs. If, however, you only intend to use command.input consistently, you could redesign without requiring a generic type argument. In essence, this would be an existentially quantified generic denoted as Command<exists T>, where exists T signifies the existence of a T without concerning its specifics. Although TypeScript does not directly support existential types, you can simulate them through some form of inversion of control:
type SomeCommand = <R, >(cb: <T, >(command: Command<T>) => R) => R;
const someCommand = <T,>(command: Command<T>): SomeCommand => cb => cb(command);
const sc = someCommand({
name: "setscore",
input: [["b", "blue", "r", "red"], Number()] as const,
resolve({ input }) {
const [teamName, score] = input
console.log("teamName", teamName, "score", score.toFixed(1));
}
});
Now, sc has a type of SomeCommand, and you can only access its properties by passing a generic callback:
sc(command => command.resolve({ input: command.input }));
// "teamName", ["b", "blue", "r", "red"], "score", "0.0"
Nonetheless, at this point, when the real utility lies in invoking resolve() with just one acceptable input, simplifying the structure might be more practical:
type SomeCommand = { name: string, callResolve(): void }
const someCommand = <T,>({ name, resolve, input }: Command<T>): SomeCommand =>
({ name, callResolve: () => resolve({ input }) });
const sc = someCommand({
name: "setscore",
input: [["b", "blue", "r", "red"], Number()] as const,
resolve({ input }) {
const [teamName, score] = input
console.log("teamName", teamName, "score", score.toFixed(1));
}
});
sc.callResolve();
// "teamName", ["b", "blue", "r", "red"], "score", "0.0"
This modification exposes a zero-argument callResolve() method instead of the resolve/input pair, streamlining operations to execute the intended task efficiently.
Hence, you have two choices: either maintain Command as generic along with monitoring the type argument effort or customize Command specifically while refining it to offer only essential non-generic functionalities required.
Playground link to code