Литеральные типы в TypeScript

// Переменная со строковым литеральным типом
let direction: "north" | "south" | "east" | "west";

// Допустимые присваивания
direction = "north";
direction = "south";

// Недопустимые присваивания вызвали бы ошибки
// direction = "northeast"; // Ошибка: тип '"northeast"' нельзя присвоить типу '"north" | "south" | "east" | "west"'
// direction = "up";        // Ошибка: тип '"up"' нельзя присвоить типу '"north" | "south" | "east" | "west"'

// Использование строковых литеральных типов в функциях
function move(direction: "north" | "south" | "east" | "west") {
  console.log(`Движение ${direction}`);
}

move("east");  // Допустимо
// move("up");  // Ошибка: аргумент типа '"up"' нельзя присвоить параметру типа...

// Переменная с числовым литеральным типом
let diceRoll: 1 | 2 | 3 | 4 | 5 | 6;

// Допустимые присваивания
diceRoll = 1;
diceRoll = 6;

// Недопустимые присваивания вызвали бы ошибки
// diceRoll = 0;      // Ошибка: тип '0' нельзя присвоить типу '1 | 2 | 3 | 4 | 5 | 6'
// diceRoll = 7;      // Ошибка: тип '7' нельзя присвоить типу '1 | 2 | 3 | 4 | 5 | 6'
// diceRoll = 2.5;    // Ошибка: тип '2.5' нельзя присвоить типу '1 | 2 | 3 | 4 | 5 | 6'

// Использование числовых литеральных типов в функциях
function rollDice(): 1 | 2 | 3 | 4 | 5 | 6 {
  return Math.floor(Math.random() * 6) + 1 as 1 | 2 | 3 | 4 | 5 | 6;
}

const result = rollDice();
console.log(`Выпало: ${result}`);

// Тип, который может быть только литеральным значением 'true'
type YesOnly = true;

// Функция, которая обязана вернуть true
function alwaysSucceed(): true {
  // Всегда возвращает литеральное значение 'true'
  return true;
}

// Логический литерал в сочетании с другими типами
type SuccessFlag = true | "success" | 1;
type FailureFlag = false | "failure" | 0;

function processResult(result: SuccessFlag | FailureFlag) {
  if (result === true || result === "success" || result === 1) {
    console.log("Операция выполнена успешно");
  } else {
    console.log("Операция не выполнена");
  }
}

processResult(true);      // "Операция выполнена успешно"
processResult("success"); // "Операция выполнена успешно"
processResult(1);         // "Операция выполнена успешно"
processResult(false);     // "Операция не выполнена"

// Объект с литеральными значениями свойств
type HTTPSuccess = {
  status: 200 | 201 | 204;
  statusText: "OK" | "Created" | "No Content";
  data: any;
};

type HTTPError = {
  status: 400 | 401 | 403 | 404 | 500;
  statusText: "Bad Request" | "Unauthorized" | "Forbidden" | "Not Found" | "Internal Server Error";
  error: string;
};

type HTTPResponse = HTTPSuccess | HTTPError;

// Здесь нужен защитник типа: одна лишь проверка числового диапазона не сужает объединение
function isSuccess(response: HTTPResponse): response is HTTPSuccess {
  return response.status >= 200 && response.status < 300;
}

function handleResponse(response: HTTPResponse) {
  if (isSuccess(response)) {
    console.log(`Успех: ${response.statusText}`);
    console.log(response.data);
  } else {
    console.log(`Ошибка ${response.status}: ${response.statusText}`);
    console.log(`Сообщение: ${response.error}`);
  }
}

// Пример использования
const successResponse: HTTPSuccess = {
  status: 200,
  statusText: "OK",
  data: { username: "john_doe", email: "john@example.com" }
};

const errorResponse: HTTPError = {
  status: 404,
  statusText: "Not Found",
  error: "Пользователь не найден в базе данных"
};

handleResponse(successResponse);
handleResponse(errorResponse);

// Простые шаблонные литералы
type Direction = "north" | "south" | "east" | "west";
type Distance = "1km" | "5km" | "10km";

// Использование шаблонных литералов для их комбинирования
type DirectionAndDistance = `${Direction}-${Distance}`;
// "north-1km" | "north-5km" | "north-10km" | "south-1km" | ...

let route: DirectionAndDistance;
route = "north-5km";   // Допустимо
route = "west-10km";   // Допустимо
// route = "north-2km";   // Ошибка
// route = "5km-north";   // Ошибка

// Продвинутые преобразования строк
type EventType = "click" | "hover" | "scroll";
type EventTarget = "button" | "link" | "div";
type EventName = `on${Capitalize<EventType>}${Capitalize<EventTarget>}`;
// "onClickButton" | "onClickLink" | "onClickDiv" | ...

// Динамический доступ к свойствам
type User = {
  id: number;
  name: string;
  email: string;
  createdAt: Date;
};

type GetterName<T> = `get${Capitalize<string & keyof T>}`;
type UserGetters = {
  [K in keyof User as GetterName<User>]: () => User[K];
};
// { getId: () => number; getName: () => string; ... }

// Сопоставление строковых шаблонов
type ExtractRouteParams<T extends string> =
  T extends `${string}:${infer Param}/${infer Rest}`
    ? Param | ExtractRouteParams<Rest>
    : T extends `${string}:${infer Param}`
      ? Param
    : never;

type Params = ExtractRouteParams<"/users/:userId/posts/:postId">;  // "userId" | "postId"

// Единицы измерения и значения CSS
type CssUnit = 'px' | 'em' | 'rem' | '%' | 'vh' | 'vw';
type CssValue = `${number}${CssUnit}`;

let width: CssValue = '100px';    // Допустимо
let height: CssValue = '50%';     // Допустимо
// let margin: CssValue = '10';   // Ошибка
// let padding: CssValue = '2ex'; // Ошибка

// Версионирование API
type ApiVersion = 'v1' | 'v2' | 'v3';
type Endpoint = 'users' | 'products' | 'orders';
type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';

type ApiUrl = `https://api.example.com/${ApiVersion}/${Endpoint}`;

// Сложный пример: динамический построитель SQL-запросов
type Table = 'users' | 'products' | 'orders';
type Column<T extends Table> =
  T extends 'users' ? 'id' | 'name' | 'email' | 'created_at' :
  T extends 'products' ? 'id' | 'name' | 'price' | 'in_stock' :
  T extends 'orders' ? 'id' | 'user_id' | 'total' | 'status' : never;

type WhereCondition<T extends Table> = {
  [K in Column<T>]?: {
    equals?: any;
    notEquals?: any;
    in?: any[];
  };
};

function query<T extends Table>(
  table: T,
  where?: WhereCondition<T>
): `SELECT * FROM ${T}${string}` {
  // В реализации здесь строился бы запрос
  return `SELECT * FROM ${table}` as const;
}

// Использование
const userQuery = query('users', {
  name: { equals: 'John' },
  created_at: { in: ['2023-01-01', '2023-12-31'] }
});
// Тип: "SELECT * FROM users WHERE ..."

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