Conditional Types

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

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

// Извлечение типа элемента массива
type ElementType<T> = T extends (infer E)[] ? E : never;

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

// Извлечение типа возврата
type MyReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

type Fn = () => string;
type R = MyReturnType<Fn>; // string

// Тип первого параметра
type FirstParam<T> = T extends (first: infer F, ...args: any[]) => any 
  ? F 
  : never;

type Fn = (name: string, age: number) => void;
type First = FirstParam<Fn>; // string

// Тип промиса
type Unpacked<T> = T extends Promise<infer U> ? U : T;

type A = Unpacked<Promise<string>>; // string
type B = Unpacked<number>;          // number

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

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

// Отключение распределения
type ToArrayNonDist<T> = [T] extends [any] ? T[] : never;

type B = ToArrayNonDist<string | number>;
// (string | number)[]

// Exclude — исключить из union
type Exclude<T, U> = T extends U ? never : T;

type A = Exclude<"a" | "b" | "c", "a">;
// "b" | "c"

// Extract — извлечь из union
type Extract<T, U> = T extends U ? T : never;

type B = Extract<"a" | "b" | "c", "a" | "d">;
// "a"

// NonNullable
type NonNullable<T> = T extends null | undefined ? never : T;

type DeepPartial<T> = T extends object
  ? { [K in keyof T]?: DeepPartial<T[K]> }
  : T;

interface User {
  name: string;
  address: {
    city: string;
    zip: string;
  };
}

type PartialUser = DeepPartial<User>;
// Все свойства опциональны, включая вложенные

type KeysOfType<T, V> = {
  [K in keyof T]: T[K] extends V ? K : never;
}[keyof T];

interface User {
  name: string;
  age: number;
  email: string;
}

type StringKeys = KeysOfType<User, string>;
// "name" | "email"