From Requirements to Classes

// One class that knows stock, members, loan rules, fees and email.
export class Library {
  constructor() {
    this.books = new Map(); // isbn -> { title, copies }
    this.members = new Map(); // id -> { name, loans: [{ isbn, day }] }
    this.outbox = [];
  }
  addBook(isbn, title, copies) { this.books.set(isbn, { title, copies }); }
  join(id, name) { this.members.set(id, { name, loans: [] }); }

  borrow(memberId, isbn, day) {
    const member = this.members.get(memberId);
    const book = this.books.get(isbn);
    if (!member || !book || book.copies === 0) return false;
    if (member.loans.length >= 3) return false; // limit: hard-wired here
    book.copies -= 1;
    member.loans.push({ isbn, day });
    this.outbox.push(`${member.name}: ${book.title} is due on day ${day + 14}`); // 14 days, once
    return true;
  }

  giveBack(memberId, isbn, day) {
    const member = this.members.get(memberId);
    const i = member ? member.loans.findIndex((l) => l.isbn === isbn) : -1;
    if (i < 0) return -1;
    const [loan] = member.loans.splice(i, 1);
    this.books.get(isbn).copies += 1;
    return Math.max(0, day - (loan.day + 14)) * 0.5; // 14 days again, plus the fee rule
  }
}

// "An electric car is a car" reads fine until someone calls refuel().
export class Vehicle {
  constructor(plate) { this.plate = plate; }
}

export class Car extends Vehicle {
  refuel() { return `${this.plate}: petrol in the tank`; }
}

export class ElectricCar extends Car {
  refuel() { throw new Error('electric cars have no tank'); } // breaks every caller of Car
  charge() { return `${this.plate}: plugged in`; }
}

export const fillUp = (vehicles) => vehicles.map((v) => v.refuel());

// The four lines you draw, as they look in code.
export class Notifier {
  send(to, text) { return `to ${to}: ${text}`; }
}
export class Book {
  constructor(isbn, title) { this.isbn = isbn; this.title = title; }
}
export class Member {
  constructor(id, name) { this.id = id; this.name = name; }
}
export class Loan {
  constructor(book, member, day) { this.book = book; this.member = member; this.day = day; } // association: knows both, owns neither
}

export class Library {
  constructor() { this.books = []; this.members = []; this.loans = []; }

  addBook(isbn, title) { // composition: created here, lives and dies with this library
    const book = new Book(isbn, title);
    this.books.push(book);
    return book;
  }
  join(member) { this.members.push(member); } // aggregation: made elsewhere, outlives this library

  lend(member, book, day, notifier) { // dependency: the notifier is only used during this call
    const loan = new Loan(book, member, day);
    this.loans.push(loan);
    return notifier.send(member.name, `borrowed ${book.title}`);
  }
}

// The rule lives in the callers, so every caller has to remember it.
export class Member {
  constructor(limit = 3) { this.limit = limit; this.loans = []; }
}

export function borrowAtDesk(member, isbn) {
  if (member.loans.length >= member.limit) return false;
  member.loans.push(isbn);
  return true;
}

export function borrowAtKiosk(member, isbn) {
  member.loans.push(isbn); // someone forgot the limit check, and nothing stops them
  return true;
}