Як працюють Utility Types під капотом

type IsString<T> = T extends string ? true : false;

type A = IsString<string>; // true
type B = IsString<number>; // false

type HasId<T> = T extends { id: string } ? true : false;

type A = HasId<{ id: string; name: string }>; // true
type B = HasId<{ name: string }>;              // false

type IsString<T> = T extends string ? true : false;

type Result = IsString<never>; // never

type IsString<T> = T extends string ? true : false;

type Result = IsString<string | number>;
// IsString<string> | IsString<number>
// true | false

type Result =
  (string extends string ? true : false) |
  (number extends string ? true : false);

type Result = true | false;

type Distributive<T> = T extends unknown ? T[] : never;

type Result = Distributive<string | number>;
// string[] | number[]

type NonDistributive<T> = [T] extends [unknown] ? T[] : never;

type Result = NonDistributive<string | number>;
// (string | number)[]

string[] | number[]

(string | number)[]

type MyExclude<T, U> = T extends U ? never : T;

type Status = "idle" | "loading" | "success" | "error";

type WithoutLoading = MyExclude<Status, "loading">;
// "idle" | "success" | "error"

type WithoutLoading =
  ("idle" extends "loading" ? never : "idle") |
  ("loading" extends "loading" ? never : "loading") |
  ("success" extends "loading" ? never : "success") |
  ("error" extends "loading" ? never : "error");

never | "idle" | never | "success" | "error"

"idle" | "success" | "error"

type MyExtract<T, U> = T extends U ? T : never;

type Values = string | number | boolean;

type OnlyPrimitive = MyExtract<Values, string | number>;
// string | number

type Exclude<T, U> = T extends U ? never : T;
type Extract<T, U> = T extends U ? T : never;

type Flags<T> = {
  [K in keyof T]: boolean;
};

type Options = {
  darkMode: boolean;
  compactMode: boolean;
};

type OptionFlags = Flags<Options>;
// {
//   darkMode: boolean;
//   compactMode: boolean;
// }

{
  [K in keyof T]: SomeType
}

type MyPartial<T> = {
  [K in keyof T]?: T[K];
};

type User = {
  id: string;
  name: string;
  age: number;
};

type UserUpdate = MyPartial<User>;
// {
//   id?: string;
//   name?: string;
//   age?: number;
// }

type UserName = User["name"]; // string
type UserField = User[keyof User]; // string | number

type MyReadonly<T> = {
  readonly [K in keyof T]: T[K];
};

type Config = MyReadonly<{
  host: string;
  port: number;
}>;

const config: Config = {
  host: "localhost",
  port: 3000,
};

// Помилка: властивість доступна лише для читання
// config.port = 4000;

type RequiredVersion<T> = {
  [K in keyof T]-?: T[K];
};

type MutableVersion<T> = {
  -readonly [K in keyof T]: T[K];
};

type Draft = {
  readonly id: string;
  name?: string;
};

type EditableDraft = MutableVersion<RequiredVersion<Draft>>;
// {
//   id: string;
//   name: string;
// }

type MyPick<T, K extends keyof T> = {
  [P in K]: T[P];
};

type User = {
  id: string;
  name: string;
  email: string;
};

type UserPreview = MyPick<User, "id" | "name">;
// {
//   id: string;
//   name: string;
// }

type MyOmit<T, K extends PropertyKey> = {
  [P in Exclude<keyof T, K>]: T[P];
};

type PublicUser = MyOmit<User, "email">;
// {
//   id: string;
//   name: string;
// }

type PropertyKey = string | number | symbol;

type UnwrapArray<T> = T extends Array<infer Item> ? Item : never;

type A = UnwrapArray<string[]>; // string
type B = UnwrapArray<number[]>; // number
type C = UnwrapArray<string>;   // never

T extends Array<infer Item>

type Pair<T> = T extends [infer First, infer Second]
  ? [Second, First]
  : never;

type Reversed = Pair<[string, number]>;
// [number, string]

type MyReturnType<T> =
  T extends (...args: never[]) => infer Result
    ? Result
    : never;

type GetUser = () => { id: string };

type User = MyReturnType<GetUser>;
// { id: string }

type Invalid = MyReturnType<string>; // never

type ReturnType<T extends (...args: any) => any> =
  T extends (...args: any) => infer R ? R : any;

type CreateUser = (name: string, age: number) => {
  id: string;
  name: string;
  age: number;
};

type CreatedUser = MyReturnType<CreateUser>;
// {
//   id: string;
//   name: string;
//   age: number;
// }

type MyParameters<T> =
  T extends (...args: infer Params) => unknown
    ? Params
    : never;

type Handler = (event: MouseEvent, id: string) => void;

type HandlerParams = MyParameters<Handler>;
// [event: MouseEvent, id: string]

type Log = (message: string, ...values: number[]) => void;

type LogParams = MyParameters<Log>;
// [message: string, ...values: number[]]

type FirstArgument<T> =
  T extends (first: infer First, ...rest: unknown[]) => unknown
    ? First
    : never;

type Result = FirstArgument<(id: string, active: boolean) => void>;
// string

type ConstructorInstance<T> =
  T extends new (...args: never[]) => infer Instance
    ? Instance
    : never;

class User {
  constructor(public id: string) {}
}

type UserInstance = ConstructorInstance<typeof User>;
// User

type ElementType<T> =
  T extends readonly (infer Item)[] ? Item : never;

type Items = ElementType<string[] | number[]>;
// string | number

type Items =
  ElementType<string[]> |
  ElementType<number[]>;
// string | number

type IsUnionArray<T> =
  [T] extends [readonly (infer Item)[]]
    ? Item
    : never;

type Result = IsUnionArray<string[] | number[]>;
// string | number

type IsExactlyString<T> =
  [T] extends [string]
    ? [string] extends [T]
      ? true
      : false
    : false;

type A = IsExactlyString<string>;        // true
type B = IsExactlyString<"hello">;       // false
type C = IsExactlyString<string | number>; // false

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

type User = {
  name: string;
  age: number;
};

type UserGetters = Getters<User>;
// {
//   getName: () => string;
//   getAge: () => number;
// }

type RemoveMethods<T> = {
  [K in keyof T as T[K] extends (...args: never[]) => unknown
    ? never
    : K]: T[K];
};

type Service = {
  name: string;
  start(): void;
  stop(): void;
};

type ServiceData = RemoveMethods<Service>;
// {
//   name: string;
// }

type MyPartial<T> = {
  [K in keyof T]?: T[K];
};

type MyReadonly<T> = {
  readonly [K in keyof T]: T[K];
};

type MyPick<T, K extends keyof T> = {
  [P in K]: T[P];
};

type MyExclude<T, U> = T extends U ? never : T;

type MyExtract<T, U> = T extends U ? T : never;

type MyReturnType<T> =
  T extends (...args: never[]) => infer Result
    ? Result
    : never;

type MyParameters<T> =
  T extends (...args: infer Params) => unknown
    ? Params
    : never;

type User = {
  id: string;
  name: string;
  age: number;
  active: boolean;
};

type UserUpdate = MyPartial<User>;
type UserPreview = MyPick<User, "id" | "name">;
type ActiveUser = MyPick<User, "active">;

type Status = "idle" | "loading" | "success" | "error";
type FinishedStatus = MyExclude<Status, "idle" | "loading">;
type LoadingStatus = MyExtract<Status, "loading" | "error">;

function createUser(name: string, age: number) {
  return {
    id: crypto.randomUUID(),
    name,
    age,
    active: true,
  };
}

type CreateUserResult = MyReturnType<typeof createUser>;
type CreateUserArguments = MyParameters<typeof createUser>;

const update: UserUpdate = {
  name: "Олена",
};

const preview: UserPreview = {
  id: "user-1",
  name: "Олена",
};

const user: CreateUserResult = createUser("Олена", 28);

function callCreateUser(...args: CreateUserArguments): CreateUserResult {
  return createUser(...args);
}

console.log(update);
console.log(preview);
console.log(user);
console.log(callCreateUser("Андрій", 31));

const status: FinishedStatus = "success";
const loading: LoadingStatus = "loading";

console.log(status, loading);

type Separate = string[] | number[];
type Mixed = (string | number)[];

const mixed: Mixed = ["text", 42, "another"];

type ToArray<T> = T extends unknown ? T[] : never;

type Result = ToArray<string | number>;
// string[] | number[]

type ToSingleArray<T> = [T] extends [unknown] ? T[] : never;

type Result = ToSingleArray<string | number>;
// (string | number)[]

type Result = string | never;
// string

type SafeReturnType<T> =
  T extends (...args: never[]) => infer Result
    ? Result
    : never;

type Valid<T> = T extends Promise<infer Value> ? Value : T;

// Некоректно:
// type Invalid<T> = Promise<infer Value>;

type User = {
  id: string;
};

type Preview = MyPick<User, "id">;

// Помилка:
// type Invalid = MyPick<User, "email">;