Продвинутые типы в TypeScript

// Превращаем все свойства в boolean
type Flags<T> = {
  [K in keyof T]: boolean;
};

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

type UserFlags = Flags<User>;
// Эквивалентно:
// {
//   id: boolean;
//   name: boolean;
//   email: boolean;
// }

// Делаем все свойства необязательными
interface Todo {
  title: string;
  description: string;
  completed: boolean;
}

type OptionalTodo = {
  [K in keyof Todo]?: Todo[K];
};

// Удаляем модификаторы 'readonly' и '?'
type Concrete<T> = {
  -readonly [K in keyof T]-?: T[K];
};

// Делаем все свойства 'readonly' и обязательными
type ReadonlyRequired<T> = {
  +readonly [K in keyof T]-?: T[K];
};

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

// Добавляем приставку ко всем именам свойств
type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

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

// Отфильтровываем свойства
type MethodsOnly<T> = {
  [K in keyof T as T[K] extends Function ? K : never]: T[K];
};

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

type A = IsString<string>;    // true
type B = IsString<number>;    // false
type C = IsString<'hello'>;    // true
type D = IsString<string | number>; // boolean

// Извлекаем тип элемента массива
type ArrayElement<T> = T extends (infer U)[] ? U : never;
type Numbers = ArrayElement<number[]>; // number

// Получаем возвращаемый тип функции
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any;

// Получаем типы параметров в виде кортежа
type Parameters<T> = T extends (...args: infer P) => any ? P : never;

// Получаем типы параметров конструктора
type ConstructorParameters<T extends new (...args: any) => any> =
  T extends new (...args: infer P) => any ? P : never;

// Получаем тип экземпляра из конструктора
type InstanceType<T extends new (...args: any) => any> =
  T extends new (...args: any) => infer R ? R : any;

// Делаем этот файл модулем, чтобы имена типов не конфликтовали со встроенными глобальными
export {};

// Без распределения
type ToArrayNonDist<T> = T extends any ? T[] : never;
type StrOrNumArr = ToArrayNonDist<string | number>; // (string | number)[]

// С распределением
type ToArray<T> = [T] extends [any] ? T[] : never;
type StrOrNumArr2 = ToArray<string | number>; // string[] | number[]

// Отфильтровываем нестроковые типы
type FilterStrings<T> = T extends string ? T : never;
type Letters = FilterStrings<'a' | 'b' | 1 | 2 | 'c'>; // 'a' | 'b' | 'c'

type Greeting = `Hello, ${string}`;

const validGreeting: Greeting = 'Hello, World!';
const invalidGreeting: Greeting = 'Hi there!'; // Ошибка

// С объединениями
type Color = 'red' | 'green' | 'blue';
type Size = 'small' | 'medium' | 'large';

type Style = `${Color}-${Size}`;
// 'red-small' | 'red-medium' | 'red-large' |
// 'green-small' | 'green-medium' | 'green-large' |
// 'blue-small' | 'blue-medium' | 'blue-large'

// Встроенные типы для работы со строками
type T1 = Uppercase<'hello'>;  // 'HELLO'
type T2 = Lowercase<'WORLD'>;  // 'world'
type T3 = Capitalize<'typescript'>;  // 'Typescript'
type T4 = Uncapitalize<'TypeScript'>;  // 'typeScript'

// Создаём тип обработчика событий
type EventType = 'click' | 'change' | 'keydown';
type EventHandler = `on${Capitalize<EventType>}`;
// 'onClick' | 'onChange' | 'onKeydown'

// Извлекаем параметры маршрута
type ExtractRouteParams<T> =
  T extends `${string}:${infer Param}/${infer Rest}`
    ? { [K in Param | keyof ExtractRouteParams<`${Rest}`>]: string }
    : T extends `${string}:${infer Param}`
    ? { [K in Param]: string }
    : {};

type Params = ExtractRouteParams<'/users/:userId/posts/:postId'>;
// { userId: string; postId: string; }

// Создаём типобезопасный генератор событий
type EventMap = {
  click: { x: number; y: number };
  change: string;
  keydown: { key: string; code: number };
};

type EventHandlers = {
  [K in keyof EventMap as `on${Capitalize<K>}`]: (event: EventMap[K]) => void;
};

// Базовые типы
interface User {
  id: number;
  name: string;
  email: string;
  createdAt: Date;
}

// Делаем все свойства необязательными
type PartialUser = Partial<User>;

// делаем все свойства обязательными
type RequiredUser = Required<PartialUser>;

// делаем все свойства только для чтения
type ReadonlyUser = Readonly<User>;

// выбираем определённые свойства
type UserPreview = Pick<User, 'id' | 'name'>;

// исключаем определённые свойства
type UserWithoutEmail = Omit<User, 'email'>;

// извлекаем типы свойств
type UserId = User['id']; // number
type UserKeys = keyof User; // 'id' | 'name' | 'email' | 'createdAt'

// Создаём тип, который исключает null и undefined
type NonNullable<T> = T extends null | undefined ? never : T;

// Исключаем типы из объединения
type Numbers = 1 | 2 | 3 | 'a' | 'b';
type JustNumbers = Exclude<Numbers, string>; // 1 | 2 | 3

// Извлекаем типы из объединения
type JustStrings = Extract<Numbers, string>; // 'a' | 'b'

// Получаем тип, которого нет во втором типе
type A = { a: string; b: number; c: boolean };
type B = { a: string; b: number };
type C = Omit<A, keyof B>; // { c: boolean }

// Создаём тип, у которого все свойства изменяемые
type Mutable<T> = {
  -readonly [K in keyof T]: T[K];
};

// Делаем этот файл модулем, чтобы имена типов не конфликтовали со встроенными глобальными
export {};

// Простое двоичное дерево
type BinaryTree<T> = {
  value: T;
  left?: BinaryTree<T>;
  right?: BinaryTree<T>;
};

// Структура данных наподобие JSON
type JSONValue =
  | string
  | number
  | boolean
  | null
  | JSONValue[]
  | { [key: string]: JSONValue };

// Вложенные комментарии
type Comment = {
  id: number;
  content: string;
  replies: Comment[];
  createdAt: Date;
};

// Делаем этот файл модулем, чтобы имена типов не конфликтовали со встроенными глобальными
export {};

// Тип для связного списка
type LinkedList<T> = {
  value: T;
  next: LinkedList<T> | null;
};

// Тип для структуры каталогов
type File = {
  type: 'file';
  name: string;
  size: number;
};

type Directory = {
  type: 'directory';
  name: string;
  children: (File | Directory)[];
};

// Тип для конечного автомата
type State = {
  value: string;
  transitions: {
    [event: string]: State;
  };
};

// Тип для рекурсивной функции
type RecursiveFunction<T> = (x: T | RecursiveFunction<T>) => void;

// Делаем этот файл модулем, чтобы имена типов не конфликтовали со встроенными глобальными
export {};