Home
/
Packages
/
boost-ts.types

boost-ts.types

Typescript advanced type collection

boost-ts.types

Collection of advanced Typescript types to boost type programming

test status

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>