Union types і композиція альтернативних типів

type Status = "pending" | "success" | "error";

function printStatus(status: Status): void {
  console.log(status);
}

printStatus("pending");
printStatus("success");

// printStatus("cancelled"); // Помилка

function printValue(value: string | number): void {
  console.log(value.toString());
}

function formatValue(value: string | number): string {
  if (typeof value === "string") {
    return value.toUpperCase();
  }

  return value.toFixed(2);
}

function describe(value: string | number | boolean): string {
  if (typeof value === "string") {
    return `Рядок із довжиною ${value.length}`;
  }

  if (typeof value === "number") {
    return `Число: ${value}`;
  }

  return `Булеве значення: ${value}`;
}

console.log(describe("TypeScript"));
console.log(describe(42));
console.log(describe(true));

function add(a: string | number, b: string | number): string | number {
  if (typeof a === "number" && typeof b === "number") {
    return a + b;
  }

  return `${a}${b}`;
}

console.log(add(2, 3)); // 5
console.log(add("Hello, ", "world")); // Hello, world
console.log(add("Версія ", 5)); // Версія 5

type EmailNotification = {
  email: string;
  subject: string;
};

type SmsNotification = {
  phone: string;
  message: string;
};

type Notification = EmailNotification | SmsNotification;

function sendNotification(notification: Notification): void {
  if ("email" in notification) {
    console.log(`Надсилаємо email на ${notification.email}`);
    console.log(`Тема: ${notification.subject}`);
  } else {
    console.log(`Надсилаємо SMS на ${notification.phone}`);
    console.log(`Текст: ${notification.message}`);
  }
}

sendNotification({
  email: "user@example.com",
  subject: "Оновлення профілю",
});

sendNotification({
  phone: "+380501234567",
  message: "Ваш код підтвердження: 1234",
});

type LoadingState = {
  status: "loading";
};

type SuccessState = {
  status: "success";
  data: string[];
};

type ErrorState = {
  status: "error";
  message: string;
};

type RequestState = LoadingState | SuccessState | ErrorState;

function renderState(state: RequestState): string {
  switch (state.status) {
    case "loading":
      return "Завантаження...";

    case "success":
      return `Отримано записів: ${state.data.length}`;

    case "error":
      return `Помилка: ${state.message}`;
  }
}

console.log(renderState({ status: "loading" }));

console.log(
  renderState({
    status: "success",
    data: ["TypeScript", "JavaScript"],
  }),
);

console.log(
  renderState({
    status: "error",
    message: "Сервер недоступний",
  }),
);

type UserId = string | number;

function getUserUrl(id: UserId): string {
  if (typeof id === "number") {
    return `/users/${id}`;
  }

  return `/users/${encodeURIComponent(id)}`;
}

console.log(getUserUrl(42));
console.log(getUserUrl("admin-user"));

function normalize(value: string | number): string {
  return String(value).trim();
}

type Admin = {
  name: string;
  permissions: string[];
};

type Customer = {
  name: string;
  ordersCount: number;
};

type User = Admin | Customer;

function getUserName(user: User): string {
  return user.name;
}

function describeUser(user: User): string {
  if ("permissions" in user) {
    return `${user.name}: дозволів ${user.permissions.length}`;
  }

  return `${user.name}: замовлень ${user.ordersCount}`;
}

type Circle = {
  kind: "circle";
  radius: number;
};

type Rectangle = {
  kind: "rectangle";
  width: number;
  height: number;
};

type Shape = Circle | Rectangle;

function isCircle(shape: Shape): shape is Circle {
  return shape.kind === "circle";
}

function getArea(shape: Shape): number {
  if (isCircle(shape)) {
    return Math.PI * shape.radius ** 2;
  }

  return shape.width * shape.height;
}

console.log(getArea({ kind: "circle", radius: 3 }));
console.log(getArea({ kind: "rectangle", width: 4, height: 5 }));

type Circle = {
  kind: "circle";
  radius: number;
};

type Rectangle = {
  kind: "rectangle";
  width: number;
  height: number;
};

type Triangle = {
  kind: "triangle";
  base: number;
  height: number;
};

type Shape = Circle | Rectangle | Triangle;

function assertNever(value: never): never {
  throw new Error(`Невідомий тип фігури: ${JSON.stringify(value)}`);
}

function getArea(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;

    case "rectangle":
      return shape.width * shape.height;

    case "triangle":
      return (shape.base * shape.height) / 2;

    default:
      return assertNever(shape);
  }
}

type Id = string | number;

type HasName = {
  name: string;
};

type HasEmail = {
  email: string;
};

type Contact = HasName & HasEmail;

const contact: Contact = {
  name: "Олена",
  email: "olena@example.com",
};

type FileResult = {
  type: "file";
  path: string;
};

type UrlResult = {
  type: "url";
  url: string;
};

type Result = FileResult | UrlResult;

function getLocation(result: Result): string {
  if (result.type === "file") {
    return result.path;
  }

  return result.url;
}

const value: string | number = 42;

// Небезпечно: фактичне значення може бути не рядком
const text = value as string;

function toUpperCase(value: string | number): string {
  if (typeof value !== "string") {
    return String(value);
  }

  return value.toUpperCase();
}

type Draft = {
  status: "draft";
  content: string;
};

type Published = {
  status: "published";
  content: string;
  publishedAt: Date;
};

type Article = Draft | Published;