ts-types-utils
Type utilities for typescript
Table of Contents
Usage
npm i -D ts-type-utilsimport * as TsTypeUtils from "ts-type-utils";Match
Match<T, M, F> // T is object, M is what to match to, F negate
Pick from T all properties that match M, or not match M if F is false
import { Match } from "ts-types-utils";
type FunctionProperties<T> = Match<T, Function>; // Match<T, Function, true>
type NonFunctionProperties<T> = Match<T, Function, false>;
type Foo = {
a: string;
b: number;
c: () => void;
d: (hello: string) => number;
};
const nonfuncs: NonFunctionProperties<Foo>; // { a: string, b: number }
const funcs: FunctionProperties<Foo>; // { c: () => void; d: (hello: string) => number }MatchNames
MatchNames<T, M, F> // T is object, M is what to match to, F negate
Get properties names from T that match M, or not match M if F is false
import { MatchNames } from "ts-types-utils";
type FunctionPropertiesNames<T> = MatchNames<T, Function>; // MatchNames<T, Function, true>
type NonFunctionPropertiesNames<T> = MatchNames<T, Function, false>;
type Foo = {
a: string;
b: number;
c: () => void;
d: (hello: string) => number;
};
const nonfuncs: NonFunctionPropertiesNames<Foo>; // "a" | "b"
const funcs: FunctionPropertiesNames<Foo>; // "c" | "d"Assign
Assign<A, B> like A & B but replaces intersected A types with the ones from B
import { Assign } from "ts-types-utils";
type A = {
foo: string;
bar: number;
};
type B = {
foo: number;
baz: boolean;
};
const bad: A & B = {
foo: 1, // error type string | number doesn't match number
bar: 2,
baz: false
};
const good: Assign<A, B> = {
foo: 1,
bar: 2,
baz: false
};Func
Func<P, R> // P: params type, R: return type
This doesn't really bring much but syntactic sugar
import { Func } from "ts-types-utils";
const myfunc: Func<[string, number], boolean>; // (a: string, b: number) => booleanPromiseOr
PromiseOr<T> = T | Promise<T>Why? Because it gets cumbersome having to repeat long types again and again. I've found myself using this a lot, specially in interfaces (for greater flexibility).
export function test(): Promise<string> | string { ... }Can be simplified to
export function test(): PromiseOr<string> { ... }Action
Action<T = void> = () => ActionWhy? Because it gets tiring and makes the code less clear having to write function types.
export function invoke(callback: () => string)): void { ... }
export function invoke(callback: () => string | number | object)): void { ... }
export function invoke(callback: () => boolean | object)): () => boolean | string { ... }Can be simplified to
export function invoke(callback: Action<string>)): void { ... }
export function invoke(callback: Action<string | number | object>): void { ... }
export function invoke(callback: Action<boolean | object>): Action<boolean | string> { ...UndefinedToOptional
UndefinedToOptional<T>import { UndefinedToOptional } from "ts-types-utils";
interface Options {
times: number | undefined
}
function foo(options: Options) {}
foo({}) // Error expected times
function bar(options: UndefinedToOptional<Options>) {}
bar({}) // Good: times is optional now
UndefinedToOptional<Options> // { times?: number }ArgsType ( DEPRECATED: already in std types as Parameters )
ArgsType<F> // F is function
Like built-in ReturnType but for the args of a function, works for any number of arguments
import { ArgsType } from "ts-types-utils";
function myFunc(a: string, b: number) {}
const all: ArgsType<typeof myFunc>; // [string, number]
const first: ArgsType<typeof myFunc>[0]; // string
const second: ArgsType<typeof myFunc>[1]; // numberRelated
Tests were made with typescript-test-utils
Contributors
- @danielpa9708
- @cloudrex
- @luisenrike