Intersection types і перетин типів

type Person = {
  name: string;
  age: number;
};

type Combined = TypeA & TypeB;

type HasId = {
  id: number;
};

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

type HasStatus = {
  status: "active" | "inactive";
};

type Entity = HasId & HasTimestamps & HasStatus;

const entity: Entity = {
  id: 1,
  createdAt: new Date(),
  updatedAt: new Date(),
  status: "active",
};

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

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

type ProductWithTimestamps = Product & Timestamps;

const product: ProductWithTimestamps = {
  id: 101,
  name: "Клавіатура",
  price: 2500,
  createdAt: new Date("2026-01-10"),
  updatedAt: new Date("2026-02-01"),
};

interface User {
  username: string;
}

interface HasEmail {
  email: string;
}

type RegisteredUser = User & HasEmail;

const registeredUser: RegisteredUser = {
  username: "marta",
  email: "marta@example.com",
};

interface User {
  username: string;
}

type HasRole = {
  role: "admin" | "editor";
};

type UserWithRole = User & HasRole;

type Authenticated = {
  userId: number;
  token: string;
};

type HasPermissions = {
  permissions: string[];
};

type AuthorizedRequest = Authenticated & HasPermissions;

function canEdit(request: AuthorizedRequest): boolean {
  return request.permissions.includes("edit");
}

const request: AuthorizedRequest = {
  userId: 42,
  token: "abc123",
  permissions: ["read", "edit"],
};

console.log(canEdit(request)); // true

type ContactInfo = {
  email: string;
  phone: string;
};

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

type Customer = ContactInfo & Address;

const contactInfo: ContactInfo = {
  email: "client@example.com",
  phone: "+380501234567",
};

const address: Address = {
  city: "Львів",
  country: "Україна",
};

const customer: Customer = {
  ...contactInfo,
  ...address,
};

function describeCustomer(customer: Customer): string {
  return `${customer.email}, ${customer.city}, ${customer.country}`;
}

console.log(describeCustomer(customer));

type BasicUser = {
  name: string;
};

type OptionalDetails = {
  age?: number;
};

type UserWithDetails = BasicUser & OptionalDetails;

const user: UserWithDetails = {
  name: "Андрій",
};

const anotherUser: UserWithDetails = {
  name: "Ірина",
  age: 31,
};

type WithStringId = {
  id: string;
};

type WithNumberId = {
  id: number;
};

type Conflicting = WithStringId & WithNumberId;

const value: Conflicting = {
  // Помилка: string не можна призначити типу never
  id: "abc",
};

type HasName = {
  name: string;
};

type HasAge = {
  age: number;
};

type Person = HasName & HasAge;

const person: Person = {
  name: "Олег",
  age: 35,
};

type Admin = {
  role: "admin";
};

type Guest = {
  role: "guest";
};

type User = Admin | Guest;

const admin: User = {
  role: "admin",
};

type Impossible = string & number;

type Identifiable = {
  id: string;
};

type Named = {
  name: string;
};

type Loggable = {
  log(): void;
};

type NamedEntity = Identifiable & Named & Loggable;

const entity: NamedEntity = {
  id: "item-1",
  name: "Документ",

  log() {
    console.log(`Об'єкт: ${this.name}, id: ${this.id}`);
  },
};

entity.log();

type Contact = {
  email: string;
};

type Phone = {
  phone: string;
};

type Customer = Contact & Phone;

type HasId = {
  id: number;
};

type HasName = {
  name: string;
};

type Entity = HasId & HasName;

const entity: Entity = {
  id: 1,
  // Помилка: відсутня обов'язкова властивість name
};

type StringValue = {
  value: string;
};

type NumberValue = {
  value: number;
};

type InvalidValue = StringValue & NumberValue;

type A = {
  a: number;
};

type B = {
  b: number;
};

type Combined = A & B;

const first: A = { a: 1 };
const second: B = { b: 2 };

const combined: Combined = {
  ...first,
  ...second,
};

type Account = {
  id: number;
  username: string;
};

type Subscription = {
  plan: "free" | "pro";
  expiresAt: Date;
};

type NotificationSettings = {
  emailNotifications: boolean;
};

type UserProfile = Account & Subscription & NotificationSettings;

function printProfile(profile: UserProfile): void {
  const plan = profile.plan === "pro" ? "Pro" : "Free";

  console.log(`Користувач: ${profile.username}`);
  console.log(`Тариф: ${plan}`);
  console.log(`Email-сповіщення: ${profile.emailNotifications ? "увімкнені" : "вимкнені"}`);
  console.log(`Підписка дійсна до: ${profile.expiresAt.toLocaleDateString("uk-UA")}`);
}

const profile: UserProfile = {
  id: 7,
  username: "software_dev",
  plan: "pro",
  expiresAt: new Date("2026-12-31"),
  emailNotifications: true,
};

printProfile(profile);