TypeScript utility types for function arguments
Use Parameters<T> instead, if you dont need something special
- Pick type of argument
- Pick args of class constructor
- Get arguments number
- Replace return type of function
- Pick specific range of arguments
- Prepend arguments
- Append arguments
Checkout typed event emitter for real-world example.
For typescript 2.8.x switch to ts280 branch.
How to use ts280 branch
npm install git://github.com/morglod/tsargs.git#ts280
npm i tsargs
import { ArgI, Arg2, Args } from 'tsargs';
function foo(a: number, b: string) {}
// Pick all args
const args: Args<typeof foo> = [ 123, 'hello' ];
// Pick by index
const firstArg: ArgI<typeof foo, 0> = 'hello world!';
// Pick by definition
const secondArg: Arg2<typeof foo> = 'hello world!';Use ArgI<Function, Index> to pick argument by it's index.
import { ArgI } from 'tsargs';
function foo(a: number, b: string) {}
const secondArg: ArgI<typeof foo, 1> = 'hello world!';ArgN variant
Use ArgN type to pick N argument (max 10 arg)
import { Arg2 } from 'tsargs';
function foo(a: number, b: string) {}
const secondArg: Arg2<typeof foo> = 'hello world!';Use CtorArgs to pick all args from constructor.
import { CtorArgs } from 'tsargs';
class A {
constructor(
public x: number,
public y: string,
public z: boolean,
) {}
}
const args: CtorArgs<typeof A> = [ 123, 'hello', false ];import { ArgsNum } from 'tsargs';
function foo(a: number, b: string): number { return 0; }
function boo(a: number, b: string, c: boolean): string { return '0'; }
const fooI: ArgsNum<typeof foo> = 2;
const booI: ArgsNum<typeof boo> = 3;import { ReplaceReturn } from 'tsargs';
function foo(a: number, b: string): number {}
function boo(a: number, b: string): string {}
const booFromFoo: ReplaceReturn<string, typeof foo> = boo;Useful for typed callbacks, rpc or event
Use PreNArgJ type to prepend N arguments to function with J arguments (max 10 arg)
or PreNArgN type to prepend N arguments to function with unknown arguments number
import { Pre1Arg2, Pre1ArgN } from 'tsargs';
function foo(a: number, b: string) {}
function boo(x: string, a: number, b: string) {}
const booFromFoo: Pre1Arg2<string, typeof foo> = boo;
const booFromFoo2: Pre1ArgN<string, typeof foo> = boo;PreNArgN type may cause low ts performance
Useful for typed callbacks, rpc or event
Use PostNArgJ type to append N arguments to function with J arguments (max 10 arg)
or PostNArgN type to append N arguments to function with unknown arguments number
import { Post1Arg2, Post1ArgN } from 'tsargs';
function foo(a: number, b: string) {}
function boo(a: number, b: string, x: string) {}
const booFromFoo: Post1Arg2<string, typeof foo> = boo;
const booFromFoo2: Post1ArgN<string, typeof foo> = boo;PostNArgN type may cause low ts performance
Callbacks & arguments list
Use Args10 to pick 10 args of function
Use ArgsNoffOffset to pick N args with Offset offset (max 10 arg)
import { Args2off1 } from 'tsargs';
function foo(a: boolean, b: number, c: string) {}
const argsBC: Args2off1<typeof foo> = [ 123, 'Hello' ];Use Args to pick all arguments
import { Args } from 'tsargs';
function foo(a: boolean, b: number, c: string) {}
const argsABC: Args<typeof foo> = [ true, 123, 'Hello' ];Args could be used in rest arguments:
const myCallbacks = {
foo: (a: number, b: number) => a + b,
boo: (a: number) => a + 10,
};
function call<
CallbackName extends keyof Callbacks,
Callbacks extends { [k: string]: (...args: any[]) => any } = typeof myCallbacks,
Callback extends (...args: any[]) => any = Callbacks[CallbackName],
>(
callbackName: CallbackName,
...args: Args<Callback> // <<<<---------------
): ReturnType<Callback> {
return (myCallbacks as { [k: string]: Function })[callbackName as any](...args);
}
call('foo', 1, 2); // ok
call('boo', 1, 2); // Error: Should be 2 args, recieved 3Checkout typed event emitter for real-world example.
- ✔️ Example of typed event emitter
- ✔️ Pick range of arguments to array type
- ✔️ Pick any number of arguments to array type
- ❌ Pick arguments to object (not needed, use tuples instead)
- ✔️ Replace return type
- Specific argument's type replace
- Remove arguments
Write issue on github if you have any trouble with arguments in typescript
Thanks CallumDenby for ArgI solution!
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent