Excluding function parameters by type in TypeScript

Question

I would like to be able to take a function with n number of arguments and return a type based on that function where any argument with type x is no longer in the function type. For example:

function myTestFunction(email: string, context: TestContext, password: string): void {
  ...
}

I would like a type to use on that to create a function definition like this:

function myTestFunction(email: string, password: string): void {
  ...
}

I've managed to do it with this:

type Filter<T> = T extends [] 
  ? [] 
  : T extends [infer A, ...infer B] 
    ? A extends TestContext 
      ? Filter<B>
      : [A, ...Filter<B>]
    : T;
type ConvertFunction<T> = T extends (...args: any[]) => any
  ? (...args: Filter<Parameters<T>>) => ReturnType<T>
  : T;

The only problem is that the parameter names are lost and the signature becomes:

function myTestFunction(args_0: string, args_1: string): void {
  ...
}

How would it be possible to do this without losing the parameter names please?

Which version of typescript are you using? IIRC there are improvements w.r.t. this in TS4+ — spender, Nov 25 '20 at 00:23
I would change `context` to be the first parameter (seems more logical anyway) and use this answer: https://stackoverflow.com/a/58765199/1517969 — olejorgenb, Sep 01 '21 at 13:28

score 0 · Accepted Answer · answered Nov 25 '20 at 00:50

Hmm, I don't think you can do this.

What you can do is spread a tuple to preserve the names

type MyTup = [a: string, b: number]
type MyTup2 = [...MyTup] // [a: string, b: number]

However, when you get a single value from a Tuple it will lose its name.

type MyTup = [a: string, b: number]
type MyTup2 = [MyTup[0], MyTup[1] // [string, string]

And if you merge an unnamed member with a named tuple, all members become unnamed:

type MyTup = [a: string, b: number]
type B = [MyTup[0], ...MyTup] // [string, string, string]

You could, of course, add names back in but there is no way I know of to actually get the name of a tuple member. So there's no way to do this generically.

type B = [asdf: MyTup[0], qwerty: MyTup[1]] // [asdf: string, qwerty: string]

All that means that when you do this:

[A, Filter<B>]

Then you are generating an unnamed tuple. And this recursive approach of re-re-re-constructing tuples is currently the only way to add or remove tuple members generically.

So I could be wrong, but I'm not sure this is possible with the current version of typescript.

Excluding function parameters by type in TypeScript

1 Answers1