Mapped types (отображённые типы) в TypeScript

type SimpleMap<T> = {
  [K in keyof T]: T[K]
}
 
interface User {
  name: string;
  age: number;
}
 
// Результат идентичен исходному типу
type MappedUser = SimpleMap<User>;
// { name: string; age: number; }

type NonNullableFields<T> = {
  [K in keyof T]: NonNullable<T[K]>
}
 
interface ApiUser {
  id: string | null;
  email: string | null;
  role: string | null;
}
 
// Убираем null из всех полей
type CleanUser = NonNullableFields<ApiUser>;
// { id: string; email: string; role: string; }

type Arrayify<T> = {
  [K in keyof T]: Array<T[K]>
}
 
interface Product {
  title: string;
  price: number;
  inStock: boolean;
}
 
type ProductBatch = Arrayify<Product>;
// {
//   title: string[];
//   price: number[];
//   inStock: boolean[];
// }

type Asyncify<T> = {
  [K in keyof T]: Promise<T[K]>
}
 
interface SyncService {
  fetchUser(): User;
  deletePost(id: string): boolean;
}
 
type AsyncService = Asyncify<SyncService>;
// {
//   fetchUser: Promise<User>;
//   deletePost: Promise<boolean>;
// }

type AddReadonly<T> = {
  +readonly [K in keyof T]: T[K]
}
 
type RemoveReadonly<T> = {
  -readonly [K in keyof T]: T[K]
}
 
interface MutableConfig {
  apiUrl: string;
  timeout: number;
}
 
// Делаем поля неизменяемыми
type ImmutableConfig = AddReadonly<MutableConfig>;
// {
//   readonly apiUrl: string;
//   readonly timeout: number;
// }

type MakeOptional<T> = {
  [K in keyof T]+?: T[K]
}
 
type MakeRequired<T> = {
  [K in keyof T]-?: T[K]
}
 
interface StrictForm {
  username: string;
  password: string;
  email: string;
}
 
// Все поля становятся опциональными
type PartialForm = MakeOptional<StrictForm>;
// {
//   username?: string;
//   password?: string;
//   email?: string;
// }

type ActionCreators<T> = {
  [K in keyof T]: {
    type: K;
    payload: T[K];
  }
}
 
interface State {
  counter: number;
  user: User | null;
  loading: boolean;
}
 
type Actions = ActionCreators<State>;
// {
//   counter: { type: "counter"; payload: number };
//   user: { type: "user"; payload: User | null };
//   loading: { type: "loading"; payload: boolean };
// }

type Getters<T> = {
  [K in keyof T]: () => T[K]
}
 
interface AppState {
  theme: 'light' | 'dark';
  language: string;
  notifications: number;
}
 
type StateGetters = Getters<AppState>;
// {
//   theme: () => 'light' | 'dark';
//   language: () => string;
//   notifications: () => number;
// }

type StringsToArrays<T> = {
  [K in keyof T]: T[K] extends string ? string[] : T[K]
}
 
interface Mixed {
  name: string;
  tags: string;
  count: number;
  active: boolean;
}
 
type Transformed = StringsToArrays<Mixed>;
// {
//   name: string[];
//   tags: string[];
//   count: number;
//   active: boolean;
// }

interface Database {
  users: User[];
  posts: Post[];
  comments: Comment[];
}
 
// Получаем union всех ключей
type TableNames = keyof Database; 
// "users" | "posts" | "comments"
 
// Извлекаем тип конкретной таблицы
type UsersTable = Database["users"]; 
// User[]
 
// Можно использовать union ключей
type AllTables = Database[keyof Database];
// User[] | Post[] | Comment[]

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
 
const user = {
  id: 42,
  name: "Alice",
  active: true
};
 
// Компилятор знает точный возвращаемый тип
const userName = getProperty(user, "name"); // string
const userId = getProperty(user, "id"); // number
 
// Ошибка компиляции - такого ключа нет
// const wrong = getProperty(user, "email");

type Arrayify<T> = {
  [K in keyof T]: Array<T[K]>
}

type AsyncifyMethods<T> = {
  [K in keyof T]: T[K] extends (...args: any[]) => any
    ? (...args: Parameters<T[K]>) => Promise<ReturnType<T[K]>>
    : T[K]
}
 
interface Service {
  config: { timeout: number };
  fetchUser(id: string): User;
  deletePost(id: number): boolean;
}
 
type AsyncService = AsyncifyMethods<Service>;
// {
//   config: { timeout: number };
//   fetchUser: (id: string) => Promise<User>;
//   deletePost: (id: number) => Promise<boolean>;
// }

interface Mixed {
  value: string | number;
}
 
type Value = Mixed["value"]; // string | number

type ArrayKeys = keyof string[]; // number | "length" | "push" | "pop" | ...
type TupleKeys = keyof [string, number]; // "0" | "1" | "length" | "push" | ...

type Partial<T> = {
  [P in keyof T]?: T[P]
}
 
interface UserProfile {
  name: string;
  email: string;
  avatar: string;
  bio: string;
}
 
// Все поля становятся необязательными
type UpdateProfile = Partial<UserProfile>;
// {
//   name?: string;
//   email?: string;
//   avatar?: string;
//   bio?: string;
// }

type Required<T> = {
  [P in keyof T]-?: T[P]
}
 
interface OptionalConfig {
  host?: string;
  port?: number;
  ssl?: boolean;
}
 
// Теперь все обязательны
type StrictConfig = Required<OptionalConfig>;
// {
//   host: string;
//   port: number;
//   ssl: boolean;
// }

type Readonly<T> = {
  readonly [P in keyof T]: T[P]
}
 
interface MutableState {
  counter: number;
  items: string[];
}
 
type ImmutableState = Readonly<MutableState>;
// {
//   readonly counter: number;
//   readonly items: string[];
// }

type Pick<T, K extends keyof T> = {
  [P in K]: T[P]
}
 
interface Article {
  id: number;
  title: string;
  content: string;
  author: string;
  publishedAt: Date;
  tags: string[];
}
 
// Выбираем только нужные поля
type ArticlePreview = Pick<Article, 'id' | 'title' | 'author'>;
// {
//   id: number;
//   title: string;
//   author: string;
// }

type Exclude<T, U> = T extends U ? never : T;
 
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

interface ExtendedUser {
  id: number;
  name: string;
  password: string;
  role: string;
  createdAt: Date;
}
 
// Убираем чувствительные данные
type PublicUser = Omit<ExtendedUser, 'password'>;
// {
//   id: number;
//   name: string;
//   role: string;
//   createdAt: Date;
// }

type Record<K extends keyof any, T> = {
  [P in K]: T
}
 
// Словарь строк
type StringDict = Record<string, string>;
 
// Енум с описаниями
type StatusDescriptions = Record<'pending' | 'success' | 'error', string>;
// {
//   pending: string;
//   success: string;
//   error: string;
// }

type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object
    ? T[P] extends Function
      ? T[P]
      : DeepReadonly<T[P]>
    : T[P]
}
 
interface NestedConfig {
  server: {
    host: string;
    port: number;
    ssl: {
      cert: string;
      key: string;
    }
  };
  cache: {
    ttl: number;
  }
}
 
type ImmutableConfig = DeepReadonly<NestedConfig>;
// Все вложенные объекты становятся readonly

type PickByType<T, V> = {
  [K in keyof T as T[K] extends V ? K : never]: T[K]
}
 
interface MixedData {
  id: number;
  name: string;
  age: number;
  active: boolean;
  email: string;
}
 
// Только числовые поля
type NumericFields = PickByType<MixedData, number>;
// {
//   id: number;
//   age: number;
// }

type Getters<T> = {
[K in keyof T & string as `get${Capitalize<K>}`]: () => T[K]
}
 
type Setters<T> = {
[K in keyof T & string as `set${Capitalize<K>}`]: (value: T[K]) => void
}
 
interface State {
counter: number;
username: string;
}
 
type StateGetters = Getters<State>;
// {
//   getCounter: () => number;
//   getUsername: () => string;
// }
 
type StateSetters = Setters<State>;
// {
//   setCounter: (value: number) => void;
//   setUsername: (value: string) => void;
// }

type ApiMethods<T> = {
[K in keyof T & string as `fetch${Capitalize<K>}`]: T[K] extends (...args: infer A) => infer R
  ? (...args: A) => Promise<R>
  : never
}
 
interface RawApi {
user: (id: string) => User;
posts: () => Post[];
comment: (postId: string, commentId: string) => Comment;
}
 
type NormalizedApi = ApiMethods<RawApi>;
// {
//   fetchUser: (id: string) => Promise<User>;
//   fetchPosts: () => Promise<Post[]>;
//   fetchComment: (postId: string, commentId: string) => Promise<Comment>;
// }

type EventHandlers<T> = {
[K in keyof T & string as `on${Capitalize<K>}${'Start' | 'End'}`]: (data: T[K]) => void
}
 
interface Events {
load: string;
save: number;
}
 
type Handlers = EventHandlers<Events>;
// {
//   onLoadStart: (data: string) => void;
//   onLoadEnd: (data: string) => void;
//   onSaveStart: (data: number) => void;
//   onSaveEnd: (data: number) => void;
// }

type RemoveDeprecated<T> = {
[K in keyof T as K extends `_deprecated_${string}` ? never : K]: T[K]
}
 
interface UserModel {
id: string;
name: string;
_deprecated_email: string;
_deprecated_phone: string;
avatar: string;
}
 
type CleanUser = RemoveDeprecated<UserModel>;
// {
//   id: string;
//   name: string;
//   avatar: string;
// }

type Invert<T extends Record<string, string>> = {
[K in keyof T as T[K]]: K
}
 
type HttpCodes = {
ok: '200';
created: '201';
badRequest: '400';
notFound: '404';
};
 
type CodeToName = Invert<HttpCodes>;
// {
//   '200': 'ok';
//   '201': 'created';
//   '400': 'badRequest';
//   '404': 'notFound';
// }

type DeepPartial<T> = {
[P in keyof T]?: T[P] extends object
  ? T[P] extends Array<infer U>
    ? Array<DeepPartial<U>>
    : T[P] extends Function
      ? T[P]
      : DeepPartial<T[P]>
  : T[P]
}
 
interface Config {
database: {
  host: string;
  credentials: {
    user: string;
    password: string;
  }
};
cache: {
  ttl: number;
  strategy: 'LRU' | 'LFU';
}
}
 
type PartialConfig = DeepPartial<Config>;
// Все уровни вложенности становятся опциональными

interface Node {
id: string;
children: Node[];
}

type DeepPartialWithDepth<T, Depth extends number = 10> = 
Depth extends 0
  ? T
  : {
      [P in keyof T]?: T[P] extends object
        ? DeepPartialWithDepth<T[P], Prev<Depth>>
        : T[P]
    }
 
// Вспомогательный тип для декремента
type Prev<T extends number> = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9][T];

type DeepSerialize<T> = T extends Date
? string
: T extends Array<infer U>
  ? Array<DeepSerialize<U>>
  : T extends object
    ? { [K in keyof T]: DeepSerialize<T[K]> }
    : T
 
interface Event {
id: number;
createdAt: Date;
metadata: {
  timestamp: Date;
  tags: string[];
}
}
 
type SerializedEvent = DeepSerialize<Event>;
// {
//   id: number;
//   createdAt: string;
//   metadata: {
//     timestamp: string;
//     tags: string[];
//   }
// }

type EditableFields<T> = {
[K in keyof T as T[K] extends Function ? never : K]: T[K]
}
 
type RemoveReadonly<T> = {
[K in keyof T as IfEquals<
  { [Q in K]: T[K] },
  { -readonly [Q in K]: T[K] },
  never,
  K
>]: T[K]
}
 
// Вспомогательный тип для сравнения
type IfEquals<X, Y, A = X, B = never> =
(<T>() => T extends X ? 1 : 2) extends
(<T>() => T extends Y ? 1 : 2) ? A : B;

type FunctionProperties<T> = {
[K in keyof T as T[K] extends Function ? K : never]: T[K]
}
 
interface Service {
config: { timeout: number };
fetchData: () => Promise<string>;
processData: (data: string) => number;
metadata: Map<string, any>;
}
 
type ServiceMethods = FunctionProperties<Service>;
// {
//   fetchData: () => Promise<string>;
//   processData: (data: string) => number;
// }

type MutableRequired<T> = {
[K in keyof T as IfEquals<
  { [Q in K]: T[K] },
  { -readonly [Q in K]-?: T[K] },
  K,
  never
>]: T[K]
}
 
interface DataModel {
readonly id: string;
name?: string;
readonly createdAt: Date;
email: string;
age: number;
}
 
type EditableRequired = MutableRequired<DataModel>;
// {
//   email: string;
//   age: number;
// }

type DeepPick<T, Path extends readonly (string | number)[]> =
Path extends readonly [infer First, ...infer Rest]
  ? First extends keyof T
    ? Rest extends readonly (string | number)[]
      ? DeepPick<T[First], Rest>
      : T[First]
    : never
  : T;
 
interface AppState {
user: {
  profile: {
    name: string;
    age: number;
  };
  settings: {
    theme: 'light' | 'dark';
    notifications: boolean;
  }
};
posts: Array<{
  id: number;
  title: string;
}>;
}
 
// Извлекаем тип по пути
type UserName = DeepPick<AppState, ['user', 'profile', 'name']>;
// string
 
type Theme = DeepPick<AppState, ['user', 'settings', 'theme']>;
// 'light' | 'dark'

// Не работает - путь выводится как string[]
const path = ['user', 'profile', 'name'];
type Wrong = DeepPick<AppState, typeof path>;
 
// Работает - путь выводится как ['user', 'profile', 'name']
const path = ['user', 'profile', 'name'] as const;
type Correct = DeepPick<AppState, typeof path>;

type DeepPickMultiple<T, Paths extends Record<string, readonly (string | number)[]>> = {
[K in keyof Paths]: DeepPick<T, Paths[K]>
}
 
type SelectedFields = DeepPickMultiple<AppState, {
name: ['user', 'profile', 'name'];
theme: ['user', 'settings', 'theme'];
}>;
// {
//   name: string;
//   theme: 'light' | 'dark';
// }

type DeepPickSafe<T, Path extends readonly any[], Depth extends number = 15> =
Depth extends 0
  ? unknown
  : Path extends readonly [infer First, ...infer Rest]
    ? First extends keyof T
      ? Rest extends readonly any[]
        ? DeepPickSafe<T[First], Rest, Prev<Depth>>
        : T[First]
      : never
    : T;

type DeepUpdate<T, Path extends readonly (string | number)[], Value> =
Path extends readonly [infer First, ...infer Rest]
  ? First extends keyof T
    ? Rest extends readonly (string | number)[]
      ? Rest['length'] extends 0
        ? { [K in keyof T]: K extends First ? Value : T[K] }
        : { [K in keyof T]: K extends First ? DeepUpdate<T[K], Rest, Value> : T[K] }
      : never
    : never
  : T;
 
type UpdatedState = DeepUpdate<AppState, ['user', 'settings', 'theme'], 'custom'>;
// Поле user.settings.theme становится 'custom' вместо 'light' | 'dark'

interface Methods {
  getValue(): string;
}
 
type Properties = {
  [K in keyof Methods]: Methods[K]
}
 
// Ошибка: методы и свойства-функции имеют разную вариантность
const props: Properties = {
  getValue: () => "test"
};
 
const methods: Methods = props; // Type error!

type HandlerMap<T> = {
  [K in keyof T]: (value: T[K]) => void
}
 
interface Events {
  click: MouseEvent;
  input: string;
}
 
// Параметры становятся ковариантными вместо контравариантных
type Handlers = HandlerMap<Events>;

type Recursive<T> = {
  [K in keyof T]: Recursive<T[K]>
}
 
interface Node {
  value: string;
  next: Node; // Циклическая структура
}
 
// Ошибка появится не сразу, а при попытке использовать
type RecursiveNode = Recursive<Node>;

type SafeRecursive<T, Depth extends number = 5> = 
  Depth extends 0 
    ? T 
    : T extends object
      ? { [K in keyof T]: SafeRecursive<T[K], Prev<Depth>> }
      : T
 
// Счётчик глубины
type Prev<N extends number> = N extends 0 ? 0 : 
  [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10][N];

// Медленно - компилятор развернёт весь union
type AllKeys<T> = T extends any ? keyof T : never;
 
// Быстрее - используем distributive хитрость
type FastKeys<T> = keyof T;
 
// Очень медленно - вложенные mapped types
type DeepTransform<T> = {
  [K in keyof T]: T[K] extends object
    ? { [P in keyof T[K]]: Transform<T[K][P]> }
    : T[K]
}
 
// Быстрее - разделяем логику
type TransformValue<V> = V extends object ? TransformObject<V> : V;
type TransformObject<T> = { [K in keyof T]: TransformValue<T[K]> };

type PluginAPI<T> = {
  [K in keyof T]: T[K] extends (...args: infer A) => infer R
    ? (...args: A) => Promise<R>
    : never
}

// Явный интерфейс для tree-shaking
interface AuthPlugin {
  login(credentials: Credentials): Promise<Token>;
  logout(): Promise<void>;
}
 
// Mapped type только для docs generation
type PluginDocs<T> = {
  [K in keyof T]: T[K] extends (...args: infer A) => infer R
    ? { args: A; returns: R }
    : never
}

type Optional<T> = {
  [K in keyof T]?: T[K]
}
 
function processData<T>(data: Optional<T>) {
  // Каждое свойство может быть undefined
  // Нужны runtime проверки которые дублируют type checking
  if (data.field !== undefined) {
    console.log(data.field.toString());
  }
}

interface FieldDescriptor<T> {
  type: T;
  required?: boolean;
  default?: T;
  transform?: {
    toApi?: (value: T) => any;
    fromApi?: (value: any) => T;
  };
}
 
type FormSchema = Record<string, FieldDescriptor<any>>;

type FormValues<S extends FormSchema> = {
  [K in keyof S]: S[K]['required'] extends true 
    ? S[K]['type']
    : S[K]['type'] | undefined
};
 
type FormErrors<S extends FormSchema> = {
  [K in keyof S]?: string
};
 
// Пример использования
const userFormSchema = {
  email: {
    type: '' as string,
    required: true,
  },
  age: {
    type: 0 as number,
    required: true,
  },
  bio: {
    type: '' as string,
    required: false,
    default: '',
  },
} as const;
 
type UserValues = FormValues<typeof userFormSchema>;
// {
//   email: string;
//   age: number;
//   bio: string | undefined;
// }

type Validator<T> = (value: T) => string | undefined;
 
type FormValidators<S extends FormSchema> = {
  [K in keyof S]?: Validator<S[K]['type']>[]
};
 
// Встроенные валидаторы с type inference
const required = <T>(message = 'Обязательное поле'): Validator<T | undefined> => 
  (value) => value === undefined || value === '' ? message : undefined;
 
const minLength = (min: number, message?: string): Validator<string> => 
  (value) => value.length < min 
    ? message || `Минимум ${min} символов`
    : undefined;
 
const email = (message = 'Невалидный email'): Validator<string> => 
  (value) => !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) ? message : undefined;
 
const range = (min: number, max: number): Validator<number> => 
  (value) => value < min || value > max 
    ? `Значение должно быть между ${min} и ${max}`
    : undefined;
 
// Использование
const validators: FormValidators<typeof userFormSchema> = {
  email: [required(), email()],
  age: [required(), range(18, 120)],
  bio: [minLength(10, 'Напишите хотя бы 10 символов о себе')],
};

function validateForm<S extends FormSchema>(
  values: Partial<FormValues<S>>,
  validators: FormValidators<S>
): FormErrors<S> {
  const errors: FormErrors<S> = {};
  
  // Итерируемся по ключам схемы
  for (const key in validators) {
    const fieldValidators = validators[key];
    if (!fieldValidators) continue;
    
    const value = values[key];
    
    // Применяем все валидаторы последовательно
    for (const validator of fieldValidators) {
      const error = validator(value as any);
      if (error) {
        errors[key] = error;
        break; // Первая ошибка останавливает проверку поля
      }
    }
  }
  
  return errors;
}

function combineValidators<T>(...validators: Validator<T>[]): Validator<T> {
  return (value) => {
    for (const validator of validators) {
      const error = validator(value);
      if (error) return error;
    }
    return undefined;
  };
}
 
// Комплексная проверка пароля
const passwordValidator = combineValidators<string>(
  required('Пароль обязателен'),
  minLength(8, 'Минимум 8 символов'),
  (value) => !/[A-Z]/.test(value) ? 'Нужна хотя бы одна заглавная буква' : undefined,
  (value) => !/[0-9]/.test(value) ? 'Нужна хотя бы одна цифра' : undefined,
);

type ApiValues<S extends FormSchema> = {
  [K in keyof S]: S[K]['transform'] extends { toApi: (value: S[K]['type']) => infer R }
    ? R
    : S[K]['type']
};
 
// Схема с трансформацией дат
const eventFormSchema = {
  title: {
    type: '' as string,
    required: true,
  },
  date: {
    type: new Date() as Date,
    required: true,
    transform: {
      toApi: (d: Date) => d.toISOString(),
      fromApi: (s: string) => new Date(s),
    },
  },
  participants: {
    type: 0 as number,
    required: true,
    transform: {
      toApi: (n: number) => String(n), // API хочет строку
      fromApi: (s: string) => parseInt(s, 10),
    },
  },
} as const;
 
type EventApiData = ApiValues<typeof eventFormSchema>;
// {
//   title: string;
//   date: string;  // Трансформирована в ISO строку
//   participants: string;  // Число стало строкой
// }

function toApiFormat<S extends FormSchema>(
  values: FormValues<S>,
  schema: S
): ApiValues<S> {
  const result: any = {};
  
  for (const key in schema) {
    const descriptor = schema[key];
    const value = values[key];
    
    result[key] = descriptor.transform?.toApi 
      ? descriptor.transform.toApi(value)
      : value;
  }
  
  return result;
}
 
function fromApiFormat<S extends FormSchema>(
  data: ApiValues<S>,
  schema: S
): FormValues<S> {
  const result: any = {};
  
  for (const key in schema) {
    const descriptor = schema[key];
    const value = data[key as keyof typeof data];
    
    result[key] = descriptor.transform?.fromApi
      ? descriptor.transform.fromApi(value)
      : value;
  }
  
  return result;
}

async function submitForm<S extends FormSchema>(
  values: FormValues<S>,
  schema: S,
  endpoint: string
) {
  const apiData = toApiFormat(values, schema);
  const response = await fetch(endpoint, {
    method: 'POST',
    body: JSON.stringify(apiData),
  });
  const responseData = await response.json();
  return fromApiFormat(responseData, schema);
}

type InferSchemaFromType<T> = {
  [K in keyof T]-?: {
    type: T[K];
    required: undefined extends T[K] ? false : true;
  }
};
 
interface UserModel {
  id: string;
  email: string;
  name?: string;
  age: number;
  verified: boolean;
}
 
type GeneratedSchema = InferSchemaFromType<UserModel>;
// {
//   id: { type: string; required: true };
//   email: { type: string; required: true };
//   name: { type: string | undefined; required: false };
//   age: { type: number; required: true };
//   verified: { type: boolean; required: true };
// }

type EnrichSchema<S, Enrichment> = {
  [K in keyof S]: K extends keyof Enrichment
    ? S[K] & Enrichment[K]
    : S[K]
};
 
const baseSchema = {} as InferSchemaFromType<UserModel>;
 
const enrichedSchema = {
  ...baseSchema,
  age: {
    ...baseSchema.age,
    default: 18,
    transform: {
      toApi: (n: number) => String(n),
      fromApi: (s: string) => parseInt(s, 10),
    },
  },
  verified: {
    ...baseSchema.verified,
    default: false,
  },
} as const;

function useTypedForm<S extends FormSchema>(
  schema: S,
  validators: FormValidators<S>,
  initialValues?: Partial<FormValues<S>>
) {
  const [values, setValues] = useState<Partial<FormValues<S>>>(() => {
    // Заполняем дефолтные значения из схемы
    const defaults: any = {};
    for (const key in schema) {
      if (schema[key].default !== undefined) {
        defaults[key] = schema[key].default;
      }
    }
    return { ...defaults, ...initialValues };
  });
  
  const [errors, setErrors] = useState<FormErrors<S>>({});
  const [touched, setTouched] = useState<Partial<Record<keyof S, boolean>>>({});
 
  // Изменение значения с валидацией
  const setValue = useCallback(<K extends keyof S>(
    field: K,
    value: FormValues<S>[K]
  ) => {
    setValues(prev => ({ ...prev, [field]: value }));
    
    // Валидируем только изменённое поле
    const fieldValidators = validators[field];
    if (fieldValidators && touched[field]) {
      const error = fieldValidators
        .map(v => v(value as any))
        .find(e => e !== undefined);
      setErrors(prev => ({ ...prev, [field]: error }));
    }
  }, [validators, touched]);
 
  // Отметить поле как тронутое
  const setFieldTouched = useCallback((field: keyof S) => {
    setTouched(prev => ({ ...prev, [field]: true }));
  }, []);
 
  // Валидация всей формы
  const validate = useCallback(() => {
    const newErrors = validateForm(values, validators);
    setErrors(newErrors);
    return Object.keys(newErrors).length === 0;
  }, [values, validators]);
 
  // Сброс формы
  const reset = useCallback(() => {
    setValues({});
    setErrors({});
    setTouched({});
  }, []);
 
  return {
    values,
    errors,
    touched,
    setValue,
    setFieldTouched,
    validate,
    reset,
  };
}

function RegistrationForm() {
  const form = useTypedForm(
    userFormSchema,
    validators,
    { bio: 'Начальное значение' }
  );
 
  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();
    
    if (!form.validate()) return;
    
    const apiData = toApiFormat(
      form.values as FormValues<typeof userFormSchema>,
      userFormSchema
    );
    
    await fetch('/api/register', {
      method: 'POST',
      body: JSON.stringify(apiData),
    });
    
    form.reset();
  };
 
  return (
    <form onSubmit={handleSubmit}>
      <input
        value={form.values.email || ''}
        onChange={e => form.setValue('email', e.target.value)}
        onBlur={() => form.setFieldTouched('email')}
      />
      {form.errors.email && <span>{form.errors.email}</span>}
      
      <input
        type="number"
        value={form.values.age || ''}
        onChange={e => form.setValue('age', parseInt(e.target.value) || 0)}
        onBlur={() => form.setFieldTouched('age')}
      />
      {form.errors.age && <span>{form.errors.age}</span>}
      
      <button type="submit">Зарегистрироваться</button>
    </form>
  );
}

// Проверка что схема генерирует правильные типы
type TestValues = FormValues<typeof userFormSchema>;
const assertEmailIsString: TestValues['email'] extends string ? true : false = true;
const assertBioIsOptional: undefined extends TestValues['bio'] ? true : false = true;
 
// Проверка что валидаторы типобезопасны
const testValidators: FormValidators<typeof userFormSchema> = {
  email: [required(), email()], // OK
  age: [required(), range(0, 150)], // OK
  // @ts-expect-error - minLength работает только со строками
  age: [minLength(5)],
};
 
// Проверка трансформации
type TestApi = ApiValues<typeof eventFormSchema>;
const assertDateTransformed: TestApi['date'] extends string ? true : false = true;

describe('Form validation', () => {
  it('validates required fields', () => {
    const values: Partial<FormValues<typeof userFormSchema>> = {
      email: '',
      age: 25,
    };
    
    const errors = validateForm(values, validators);
    
    expect(errors.email).toBeDefined();
    expect(errors.age).toBeUndefined();
  });
 
  it('transforms data correctly', () => {
    const formData: FormValues<typeof eventFormSchema> = {
      title: 'Test Event',
      date: new Date('2024-01-01'),
      participants: 42,
    };
    
    const apiData = toApiFormat(formData, eventFormSchema);
    
    expect(typeof apiData.date).toBe('string');
    expect(typeof apiData.participants).toBe('string');
    expect(apiData.participants).toBe('42');
  });
});