TypeScript 5: новые возможности — оператор satisfies, декораторы, const-параметры типа

// ❌ Проблема старого подхода
type Color = "red" | "green" | "blue";
type ColorMap = Record<string, string | number[]>;

// Утверждение as: проверка типа есть, вывода нет
const palette = {
  red: [255, 0, 0],
  green: "#00ff00",
  blue: [0, 0, 255]
} as ColorMap;

// palette.red теперь выводится как string | number[]
// Для использования .map() нужно утверждение типа
palette.red.map(x => x); // Ошибка! У string | number[] нет map

// ✅ Оператор satisfies
type Color = "red" | "green" | "blue";
type ColorMap = Record<Color, string | number[]>;

const palette = {
  red: [255, 0, 0],
  green: "#00ff00",
  blue: [0, 0, 255]
} satisfies ColorMap;

// Проверка типа есть, литеральный вывод тоже есть
palette.red.map(x => x);      // ✅ number[] сохраняется
palette.green.toUpperCase();   // ✅ string сохраняется
const wrong = { purple: "purple" } satisfies ColorMap; // ❌ Ошибка: "purple" не является Color

interface ApiConfig {
  baseUrl: string;
  timeout: number;
  retries: number;
}

// satisfies: проверка типа + точный вывод значений
const config = {
  baseUrl: "https://api.example.com",
  timeout: 5000,
  retries: 3,
} satisfies ApiConfig;

// config.timeout — это 5000 (литеральный тип), а не просто number
type TimeoutType = typeof config.timeout; // 5000

type Route = {
  path: string;
  component: React.ComponentType;
  auth?: boolean;
};

const routes = [
  { path: "/", component: Home },
  { path: "/dashboard", component: Dashboard, auth: true },
] satisfies Route[];

// routes[0].path сохраняется как "/" (литерал), проверка Route тоже проходит

type TranslationKey = "hello" | "goodbye" | "welcome";
type Translations = Record<TranslationKey, string>;

const ko = {
  hello: "Привет",
  goodbye: "До свидания",
  welcome: "Добро пожаловать",
} satisfies Translations;

const en = {
  hello: "Hello",
  goodbye: "Goodbye",
  // welcome отсутствует → ошибка компиляции! ✅
} satisfies Translations;

// ✅ Стандартный декоратор TypeScript 5
function sealed(target: typeof SealedClass) {
  Object.seal(target);
  Object.seal(target.prototype);
}

@sealed
class SealedClass {
  greet() { return "Hello!"; }
}

function log(target: any, context: ClassMethodDecoratorContext) {
  const methodName = String(context.name);

  return function (this: any, ...args: any[]) {
    console.log(`[${methodName}] вызван, аргументы:`, args);
    const result = target.call(this, ...args);
    console.log(`[${methodName}] возвращает:`, result);
    return result;
  };
}

class Calculator {
  @log
  add(a: number, b: number): number {
    return a + b;
  }
}

const calc = new Calculator();
calc.add(1, 2);
// [add] вызван, аргументы: [1, 2]
// [add] возвращает: 3

function readonly(target: any, context: ClassAccessorDecoratorContext) {
  return {
    set() {
      throw new Error(`${String(context.name)} доступен только для чтения.`);
    }
  };
}

class Config {
  @readonly
  accessor version = "1.0.0";
}

const cfg = new Config();
console.log(cfg.version); // "1.0.0"
cfg.version = "2.0.0";    // ❌ Ошибка

// Использование Metadata API
function validate(target: any, context: ClassFieldDecoratorContext) {
  context.metadata[context.name] = { required: true };
}

class UserForm {
  @validate
  name!: string;

  @validate
  email!: string;
}

// Чтение метаданных
const metadata = UserForm[Symbol.metadata];
console.log(metadata); // { name: { required: true }, email: { required: true } }

// ❌ Старый подход
function identity<T>(value: T): T {
  return value;
}

const result = identity(["a", "b", "c"]);
// result: string[] (литерал утрачивается)

// ✅ Параметр типа const
function identityConst<const T>(value: T): T {
  return value;
}

const result2 = identityConst(["a", "b", "c"]);
// result2: readonly ["a", "b", "c"] (литерал сохраняется!)

function createRoute<const Path extends string>(path: Path) {
  return { path, url: () => `https://app.example.com${path}` };
}

const homeRoute = createRoute("/");
// homeRoute.path: "/" (литерал сохраняется)

const dashRoute = createRoute("/dashboard");
// dashRoute.path: "/dashboard" (литерал сохраняется)

// tsconfig.json
{
  "extends": [
    "@tsconfig/strictest/tsconfig.json",
    "@tsconfig/node18/tsconfig.json",
    "./custom.tsconfig.json"
  ],
  "compilerOptions": {
    "outDir": "dist"
  }
}

// Объект с Symbol.dispose
class DatabaseConnection {
  connect() { console.log("Подключено к БД"); }
  [Symbol.dispose]() { console.log("Соединение с БД закрыто"); }
}

// using: автоматический вызов dispose при выходе из области видимости
function queryDatabase() {
  using conn = new DatabaseConnection();
  conn.connect();
  // ... выполнение запросов
  // conn[Symbol.dispose]() вызывается автоматически при возврате
}

// ❌ Без NoInfer: TypeScript выводит тип из обоих параметров
function setDefault<T>(values: T[], defaultValue: T): T {
  return values.length > 0 ? values[0] : defaultValue;
}

setDefault(["a", "b"], "c"); // OK
setDefault(["a", "b"], 42);  // OK... но нежелательно

// ✅ С NoInfer: вывод только из первого параметра
function setDefaultStrict<T>(values: T[], defaultValue: NoInfer<T>): T {
  return values.length > 0 ? values[0] : defaultValue;
}

setDefaultStrict(["a", "b"], "c"); // OK: "c" — string
setDefaultStrict(["a", "b"], 42);  // Ошибка: 42 не является string