ts-types-utils
    TypeScript icon, indicating that this package has built-in type declarations

    1.5.0 • Public • Published

    ts-types-utils

    npm version Conventional Commits code style: prettier

    Type utilities for typescript

    Table of Contents

    Usage

    npm i -D ts-type-utils
    import * 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) => boolean

    PromiseOr

    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> = () => Action

    Why? 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]; // number

    Related

    Tests were made with typescript-test-utils

    Contributors

    • @danielpa9708
    • @cloudrex
    • @luisenrike

    Install

    npm i ts-types-utils

    DownloadsWeekly Downloads

    0

    Version

    1.5.0

    License

    MIT

    Unpacked Size

    16.5 kB

    Total Files

    19

    Last publish

    Collaborators

    • danielpanpm