tsargs

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.

Tested with static asserts

⚠️ Should use latest typescript version. ⚠️

For typescript 2.8.x switch to ts280 branch.

How to use ts280 branch

npm install git://github.com/morglod/tsargs.git#ts280

Install & use

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!';

Pick argument

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!';

Class constructor

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 ];

Get arguments number

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;

Replace return type of function

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;

Prepend arguments

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

Append arguments

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

Pick range of arguments

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 3

Checkout typed event emitter for real-world example.

Roadmap

• ✔️ 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

Contributors

Thanks CallumDenby for ArgI solution!