boost-ts.types

Collection of advanced Typescript types to boost type programming

This collection mainly offers type operation for structured/complicated types, like tuple, union, object data type. By using this collection, "as any" can be avoided for the complicated type of Typescript functions.

KeyPath

Basic

Generate key path from data type

Data Type

type Sprinter = {
    "name": string
    "best": {
        "100m": number
        "200m": number
    }
}

Key Path

const target:KeyPath<Sprinter> = {
    "name": "Usain Bolt"
    "best.100m" : 9.58
    "best.200m" : 19.19
}

Key path format

The format of key path is customizable.

KeyPath<T, Sep, HeadingSep, ValueType>

• T: Data type
• Sep: Separator (string, default: ".")
• HeadingSep: Adding separtor at the head (boolean, default: false)
• ValueType: key path is generated for the specified value type (type, default: any)

Directory path format

const target:KeyPath<Sprinter, "/", true> = {
    "/name": "Usain Bolt"
    "/best/100m" : 9.58
    "/best/200m" : 19.19
}

KeyArray

const target:KeyArray<Sprinter> = {
    [ [ "name" ], "Usain Bolt" ],
    [ [ "best", "100m" ], 9.58 ],
    [ [ "best", "200m" ], 19.19 ]
]

Tuple

Head

Get the head of type tuple.

// type Target = Date
type Target = Head<[Date, string, number]>

Tail

Remove a type from the head of type tuple.

// type Target = [string, number]
type Target = Tail<[Date, string, number]>

Push

Add a type to the head of type tuple.

// type Target = [Date, string, number]
type Target = Push<Date, [string, number]>

Reverse

Reverse the order of type tuple.

// Target = [number, string, boolean]
type Target = Reverse<[boolean, string, number]>

TupleOmit

Remove a type from type tuple.

// Target = [boolean, number]
type Target = TupleOmit<string, [boolean, string, number]>

TuplePick

Fileter a type from type tuple.

// Target = [string, number]
type Target = TuplePick<string|number, [boolean, string, number]>

Zip

Zip two type tuples.

// Target = [ [1, boolean], [2, string, [3, number] ]
type Target = Zip<[1, 2, 3], [boolean, string, number]>

Number

Decrease

Decrease a number type.

// Target = 3
type Target = Decrease<4>

Comp

Compare two number types.

// Target1 = -1
type Target1 = Comp<1, 2>
// Target2 = 0
type Target2 = Comp<2, 2>
// Target3 = 1
type Target3 = Comp<2, 1>

• Some code of this library is based on this stackoverflow article.
• Thanks to the blog Suppress Error of type level programming of TypeScript. This library will be nothing without workarounds suggested by this blog. Japanese version is also published.
• typepark is an excellent library that provides the large collection of typescript types manipulation.
• The code of Equals implementation is copied from this comment
• How to break the limit of recursived type is a great article (written in Japanese).