[TypeScript] Transform Existing Types Using Mapped Types in TypeScript

Mapped types are a powerful and unique feature of TypeScript's type system. They allow you to create a new type by transforming all properties of an existing type according to a given transformation function. In this lesson, we'll cover mapped types like Readonly<T> or Partial<T> that ship with the TypeScript compiler, and we'll also explore how to create our own type transformations.

There are few mapped types built-in:

/**
 * Make all properties in T optional
 */
type Partial<T> = {
    [P in keyof T]?: T[P];
};

/**
 * Make all properties in T readonly
 */
type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};

/**
 * From T pick a set of properties K
 */
type Pick<T, K extends keyof T> = {
    [P in K]: T[P];
};

/**
 * Construct a type with a set of properties K of type T
 */
type Record<K extends string, T> = {
    [P in K]: T;
};

Take readonly as an example, the output is like this:

interface Point {
   x: number;
   y: number;
}

ReadonlyPoint = Readonly<Point>;

type ReadonlyPoint = {
    readonly x: number;
    readonly y: number;
}

So for each props in Point, we append 'readonly' type for it.

The way type resolve:

interface Point {
    x: number;
    y: number;
}

// From
type ReadonlyPoint = {
    readonly [P in keyof Point]: Point[P]
}

type ReadonlyPoint = {
    readonly [P in "x" | "y"]: Point[P]
}

type ReadonlyPoint = {
    readonly x: Point["x"];
    readonly y: Point["y"];
}

// To
type ReadonlyPoint = {
    readonly x: number
    readonly y: number;
}

The same process can be done with Partial type:

type PartialPoint = Partial<Point>;

// From
type PartialPoint = {
    [P in keyof T]?: T[P];
}

type PartialPoint = {
    [P in keyof Point]?: Point[P];
}

type PartialPoint = {
    [P in "x" | "y"]?: Point[P];
}

type PartialPoint = {
    x?: Point["x"];
    y?: Point["y"];
}

// To
type PartialPoint = {
    x?: number;
    y?: number;
}

We can also write Nullable type by ourselves:

type Nullable<T> = {
   [P in keyof T]: T[P] | null
}

For each Prop fo Type T, it can be its value or null.

We can also combine different type together:

type Nullable<T> = {
    [P in keyof T]: T[P] | null
}

type Stringify<T> = {
    [P in keyof T]: string
}

type NullablePoint = Nullable<Point>
type PartialNullablePoint = Partial<Nullable<Stringify<Point>>>