Partial, Required і Readonly: модифікація властивостей типу

const user: User = {
  id: 1,
  name: "Олена"
};

const product: Product = {
  id: 10,
  name: "Клавіатура"
};

// Помилка TypeScript:
// product.id = 20;

interface User {
  id: number;
  name: string;
  email: string;
}

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

type UserUpdate = Partial<User>;

const update: UserUpdate = {
  name: "Олена Коваль"
};

type UserUpdate = {
  id?: number;
  name?: string;
  email?: string;
};

interface User {
  id: number;
  name: string;
  email: string;
}

function updateUser(user: User, changes: Partial<User>): User {
  return {
    ...user,
    ...changes
  };
}

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

const updatedUser = updateUser(user, {
  name: "Олена Коваль"
});

console.log(updatedUser);

const firstUpdate = updateUser(user, {
  name: "Ірина"
});

const secondUpdate = updateUser(user, {
  email: "iryna@example.com"
});

// Помилка TypeScript:
// const update = updateUser(user, {
//   age: 25
// });

interface Settings {
  theme: string;
  notifications: {
    email: boolean;
    sms: boolean;
  };
}

type PartialSettings = Partial<Settings>;

const settings: PartialSettings = {
  notifications: {
    email: true,
    sms: false
  }
};

// Помилка TypeScript:
// const settings: PartialSettings = {
//   notifications: {
//     email: true
//   }
// };

interface FormData {
  username: string;
  password: string;
  rememberMe?: boolean;
}

type CompleteFormData = Required<FormData>;

const form: CompleteFormData = {
  username: "olena",
  password: "secret",
  rememberMe: true
};

type CompleteFormData = {
  username: string;
  password: string;
  rememberMe: boolean;
};

// Помилка TypeScript:
// const form: CompleteFormData = {
//   username: "olena",
//   password: "secret"
// };

interface AppConfig {
  host?: string;
  port?: number;
  debug?: boolean;
}

function createConfig(): Required<AppConfig> {
  return {
    host: "localhost",
    port: 3000,
    debug: false
  };
}

const config = createConfig();

console.log(config.host);
console.log(config.port);
console.log(config.debug);

interface User {
  id: number;
  name: string;
}

type ReadonlyUser = Readonly<User>;

const user: ReadonlyUser = {
  id: 1,
  name: "Олена"
};

console.log(user.name);

// Помилки TypeScript:
// user.id = 2;
// user.name = "Ірина";

type ReadonlyUser = {
  readonly id: number;
  readonly name: string;
};

interface Product {
  id: number;
  name: string;
  price: number;
}

function printProduct(product: Readonly<Product>): void {
  console.log(`${product.name}: ${product.price} грн`);

  // Помилка TypeScript:
  // product.price = 0;
}

const product: Product = {
  id: 1,
  name: "Навушники",
  price: 1200
};

printProduct(product);

interface User {
  id: number;
  name: string;
  email: string;
}

type ReadonlyUserUpdate = Readonly<Partial<User>>;

const update: ReadonlyUserUpdate = {
  name: "Олена"
};

console.log(update.name);

// Помилка TypeScript:
// update.name = "Ірина";

interface Profile {
  id: number;
  name: string;
  email?: string;
}

// Усі властивості необов'язкові.
// Використовується для часткового оновлення профілю.
type ProfileUpdate = Partial<Profile>;

// Властивість email стає обов'язковою.
type CompleteProfile = Required<Profile>;

// Усі властивості доступні лише для читання.
type ReadonlyProfile = Readonly<Profile>;

function updateProfile(
  profile: Profile,
  changes: ProfileUpdate
): Profile {
  return {
    ...profile,
    ...changes
  };
}

const profile: Profile = {
  id: 1,
  name: "Олена"
};

const updatedProfile = updateProfile(profile, {
  name: "Олена Коваль",
  email: "olena@example.com"
});

const completeProfile: CompleteProfile = {
  id: 1,
  name: "Олена Коваль",
  email: "olena@example.com"
};

const readonlyProfile: ReadonlyProfile = completeProfile;

console.log(updatedProfile);
console.log(readonlyProfile.name);

// Помилка TypeScript:
// readonlyProfile.name = "Ірина";

interface Settings {
  theme?: string;
}

type A = Partial<Settings>;
// theme?: string

type B = Required<Settings>;
// theme: string

type C = Readonly<Settings>;
// readonly theme?: string

interface User {
  name: string;
  address: {
    city: string;
    country: string;
  };
}

type UserUpdate = Partial<User>;

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

interface Counter {
  value: number;
}

const counter: Readonly<Counter> = {
  value: 0
};

// TypeScript не дозволяє:
// counter.value = 1;

interface Options {
  color?: string;
  size?: number;
}

type CompleteOptions = Required<Options>;

// Помилка TypeScript:
// const options: CompleteOptions = {
//   color: "blue"
// };

const options: CompleteOptions = {
  color: "blue",
  size: 10
};