Challenge 2 — Solution

Task: Using the EventEmitter class from this chapter, create an
instance and register two separate listeners for an "orderPlaced"
event — one logging a confirmation message, one logging that an
email should be sent. Emit the event once with an order ID and
confirm both listeners run.

class EventEmitter {
    constructor() {
        this.listeners = {};
    }

    on(event, callback) {
        if (!this.listeners[event]) this.listeners[event] = [];
        this.listeners[event].push(callback);
    }

    emit(event, data) {
        (this.listeners[event] || []).forEach(callback => callback(data));
    }
}

const emitter = new EventEmitter();

emitter.on("orderPlaced", orderId => {
    console.log(`Order confirmed: ${orderId}`);
});

emitter.on("orderPlaced", orderId => {
    console.log(`Sending confirmation email for order: ${orderId}`);
});

emitter.emit("orderPlaced", "ORD-1001");


Expected output:

Order confirmed: ORD-1001
Sending confirmation email for order: ORD-1001


Notes:
- Both listeners were registered for the SAME event name
  ("orderPlaced"), so a single emit() call triggers both, in the
  order they were registered — this.listeners["orderPlaced"] is an
  array holding both callback functions.
- emitter itself has no idea what either listener actually does —
  it just calls every registered callback with whatever data was
  passed to emit(), the defining trait of the observer pattern.
- A third, completely unrelated listener could be added later for
  the same event without touching either of these two — that
  decoupling is the whole point of this pattern.