Type Aliases

type User = {
  id: string;
  name: string;
  email: string;
  isActive: boolean;
};

const user: User = {
  id: "user-1",
  name: "Олена",
  email: "olena@example.com",
  isActive: true,
};

type User = {
  id: string;
  name: string;
  email: string;
  isActive: boolean;
};

function printUser(user: User): string {
  return `${user.name} <${user.email}>`;
}

function findActiveUsers(users: User[]): User[] {
  return users.filter((user) => user.isActive);
}

const users: User[] = [
  {
    id: "user-1",
    name: "Олена",
    email: "olena@example.com",
    isActive: true,
  },
  {
    id: "user-2",
    name: "Андрій",
    email: "andrii@example.com",
    isActive: false,
  },
];

console.log(printUser(users[0]));
console.log(findActiveUsers(users));

type Product = {
  id: number;
  title: string;
  price: number;
};

const product: Product = {
  id: 1,
  title: "Клавіатура",
  // Помилка: price має бути вказаною і мати тип number
};

type Profile = {
  username: string;
  bio?: string;
};

const firstProfile: Profile = {
  username: "coder",
};

const secondProfile: Profile = {
  username: "typescript_dev",
  bio: "Розробляю вебзастосунки",
};

type Configuration = {
  readonly environment: "development" | "production";
  apiUrl: string;
};

const configuration: Configuration = {
  environment: "development",
  apiUrl: "https://example.com",
};

// Помилка: властивість доступна лише для читання
// configuration.environment = "production";

configuration.apiUrl = "https://api.example.com";

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

let requestStatus: Status = "pending";

requestStatus = "success";
// requestStatus = "cancelled"; // Помилка: такого значення немає в Status

type ApiResponse =
  | {
      status: "success";
      data: string[];
    }
  | {
      status: "error";
      message: string;
    };

function handleResponse(response: ApiResponse): void {
  if (response.status === "success") {
    console.log("Отримано елементів:", response.data.length);
  } else {
    console.error("Помилка:", response.message);
  }
}

handleResponse({
  status: "success",
  data: ["TypeScript", "JavaScript"],
});

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

type Timestamps = {
  createdAt: Date;
  updatedAt: Date;
};

type Identifiable = {
  id: string;
};

type Document = Timestamps & Identifiable & {
  title: string;
};

const document: Document = {
  id: "doc-1",
  title: "Посібник TypeScript",
  createdAt: new Date(),
  updatedAt: new Date(),
};

type WithId = {
  id: string;
};

type Article = WithId & {
  title: string;
  content: string;
};

type Video = WithId & {
  title: string;
  durationInSeconds: number;
};

type Formatter = (value: number) => string;

const formatPrice: Formatter = (value) => {
  return `${value.toFixed(2)} грн`;
};

const formatPercent: Formatter = (value) => {
  return `${value}%`;
};

console.log(formatPrice(1250));
console.log(formatPercent(15));

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

type UserFactory = (name: string) => User;

const createUser: UserFactory = (name) => {
  return {
    id: crypto.randomUUID(),
    name,
  };
};

console.log(createUser("Марія"));

type Score = number;
type Scores = Score[];

const scores: Scores = [10, 8, 9];

type Task = {
  id: number;
  title: string;
  completed: boolean;
};

type TaskList = Task[];

const tasks: TaskList = [
  {
    id: 1,
    title: "Вивчити type alias",
    completed: true,
  },
  {
    id: 2,
    title: "Написати приклад",
    completed: false,
  },
];

type Coordinates = [number, number];

const point: Coordinates = [50.4501, 30.5234];

// Помилка: у кортежі мають бути два числа
// const invalidPoint: Coordinates = [50.4501];

type Id = string;

type Address = {
  city: string;
  street: string;
};

type Customer = {
  id: Id;
  name: string;
  address: Address;
};

const customer: Customer = {
  id: "customer-1",
  name: "Ірина",
  address: {
    city: "Львів",
    street: "вулиця Шевченка",
  },
};

type Product = {
  id: string;
  name: string;
  price: number;
};

type ProductPreview = Pick<Product, "id" | "name">;
type ProductUpdate = Partial<Product>;

const preview: ProductPreview = {
  id: "product-1",
  name: "Монітор",
};

const update: ProductUpdate = {
  price: 8999,
};

type UserByType = {
  id: string;
  name: string;
};

interface UserByInterface {
  id: string;
  name: string;
}

type Result = string | number;

type UserId = string;
type OrderId = string;

const userId: UserId = "user-1";
const orderId: OrderId = "order-1";

const anotherOrderId: OrderId = userId;

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

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

type SuccessState = {
  status: "success";
  users: User[];
};

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

type UsersState = LoadingState | SuccessState | ErrorState;

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

    case "success":
      return `Користувачів: ${state.users.length}`;

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

const states: UsersState[] = [
  { status: "loading" },
  {
    status: "success",
    users: [
      { id: "user-1", name: "Олена" },
      { id: "user-2", name: "Андрій" },
    ],
  },
  {
    status: "error",
    message: "Не вдалося отримати дані",
  },
];

for (const state of states) {
  console.log(renderUsersState(state));
}

type User = {
  name: string;
};

type Product = {
  id: string;
  name: string;
  price: number;
};

function getProduct(): Product {
  return {
    id: "product-1",
    name: "Ноутбук",
    price: 42000,
  };
}

function printProduct(product: Product): void {
  console.log(product.name, product.price);
}

type Theme = "light" | "dark";

function setTheme(theme: Theme): void {
  console.log(`Обрана тема: ${theme}`);
}

setTheme("dark");
// setTheme("blue"); // Помилка

type Id = string | number;

type Entity = {
  id: string;
} & {
  createdAt: Date;
};