tsargs

typescript function arguments utils

  • tsargs

Downloads in past

Stats

StarsIssuesVersionUpdatedCreatedSize
tsargs
2811.4.13 years ago6 years agoMinified + gzip package size for tsargs in KB

Readme

NPM Version
NPM Downloads
tsargs
TypeScript utility types for function arguments
Use Parameters\ instead, if you dont need something special

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!