Assertion Functions

function assert(condition: unknown, message: string): asserts condition {
  if (!condition) {
    throw new Error(message);
  }
}

function printUserName(name: string | null): void {
  assert(name !== null, "Ім'я користувача відсутнє");

  // Після assert TypeScript знає, що name має тип string
  console.log(name.toUpperCase());
}

printUserName("Olena");

assert(name !== null, "Ім'я користувача відсутнє");

printUserName(null);
// Error: Ім'я користувача відсутнє

function assertIsString(value: unknown): asserts value is string {
  if (typeof value !== "string") {
    throw new TypeError("Очікувався рядок");
  }
}

function printLength(value: unknown): void {
  assertIsString(value);

  // Після перевірки value має тип string
  console.log(value.length);
}

printLength("TypeScript");

assertIsString(value);

type User = {
  id: number;
  name: string;
};

function assertIsUser(value: unknown): asserts value is User {
  if (typeof value !== "object" || value === null) {
    throw new TypeError("Значення не є об'єктом");
  }

  const user = value as Record<string, unknown>;

  if (typeof user.id !== "number" || typeof user.name !== "string") {
    throw new TypeError("Некоректна структура користувача");
  }
}

const input: unknown = JSON.parse('{"id": 42, "name": "Iryna"}');

assertIsUser(input);

// Після assertion input має тип User
console.log(input.id);
console.log(input.name.toUpperCase());

function isString(value: unknown): value is string {
  return typeof value === "string";
}

const value: unknown = "hello";

if (isString(value)) {
  console.log(value.toUpperCase());
}

function assertIsString(value: unknown): asserts value is string {
  if (typeof value !== "string") {
    throw new TypeError("Очікувався рядок");
  }
}

const value: unknown = "hello";

assertIsString(value);
console.log(value.toUpperCase());

function assertDefined<T>(
  value: T,
  message = "Значення не визначене"
): asserts value is NonNullable<T> {
  if (value === null || value === undefined) {
    throw new Error(message);
  }
}

function getFirstItem(items: string[]): string {
  const firstItem: string | undefined = items[0];

  assertDefined(firstItem, "Список порожній");

  // firstItem має тип string
  return firstItem;
}

console.log(getFirstItem(["TypeScript", "JavaScript"]));

NonNullable<string | null | undefined>
// string

type Success = {
  status: "success";
  data: string;
};

type Failure = {
  status: "failure";
  error: string;
};

type Result = Success | Failure;

function assertSuccess(result: Result): asserts result is Success {
  if (result.status !== "success") {
    throw new Error(result.error);
  }
}

function processResult(result: Result): string {
  assertSuccess(result);

  // result має тип Success
  return result.data.toUpperCase();
}

console.log(processResult({
  status: "success",
  data: "completed"
}));

function assertPositive(value: number): asserts value is number {
  if (value <= 0) {
    throw new Error("Число має бути додатним");
  }
}

function assertIsNumber(value: unknown): asserts value is number {
  // Помилка: перевірки немає
}

const value: unknown = "not a number";

assertIsNumber(value);

// TypeScript вважає value числом,
// хоча фактично це рядок
console.log(value.toFixed(2));

function assertIsString(value: unknown): asserts value is string {
  if (typeof value !== "string") {
    console.log("Неправильний тип");
  }
}

function assertIsString(value: unknown): asserts value is string {
  if (typeof value !== "string") {
    throw new TypeError("Очікувався рядок");
  }
}

type User = {
  id: number;
  name: string;
};

function assertIsUser(value: unknown): asserts value is User {
  if (typeof value === "object" && value !== null) {
    // Цієї перевірки недостатньо для типу User
  }
}

function assert(condition: unknown): asserts condition {
  if (!condition) {
    throw new Error("Умова не виконана");
  }
}

function assertIsNumber(value: unknown): asserts value is number {
  if (typeof value !== "number") {
    throw new TypeError("Очікувалося число");
  }
}

function isNumber(value: unknown): value is number {
  return typeof value === "number";
}

function formatValue(value: unknown): string {
  if (isNumber(value)) {
    return value.toFixed(2);
  }

  return "Значення не є числом";
}