# Mediator Pattern

The Mediator Pattern is a behavioral design pattern that lets you reduce chaotic dependencies between objects. The pattern restricts direct communications between the objects and forces them to collaborate only via a mediator object.

## 1. The Core Concept

As an application grows, the number of connections between classes can increase exponentially. If every object talks to every other object (Many-to-Many), the system becomes a tangled mess (Spaghetti Code).

*   **Mediator:** An object that encapsulates how a set of objects interact.
*   **Colleagues:** The objects that communicate through the mediator. They do not know about each other.

## 2. Analogy: Air Traffic Control

Pilots of aircraft approaching an airport do not communicate directly with each other to decide who lands first.
*   **Pilots (Colleagues):** Communicate only with the Air Traffic Control tower.
*   **ATC (Mediator):** Receives messages from pilots and issues commands to ensure safety.

Without the ATC, pilots would have to know the position of every other plane, which is impossible.

## 3. Example (TypeScript)

Let's simulate a simple dialog box with a button and a checkbox.

```typescript
// The Mediator Interface
interface Mediator {
    notify(sender: object, event: string): void;
}

// The Base Component
class BaseComponent {
    protected mediator: Mediator;

    constructor(mediator: Mediator) {
        this.mediator = mediator;
    }
}

// Concrete Component 1
class Button extends BaseComponent {
    click() {
        console.log("Button clicked.");
        this.mediator.notify(this, "click");
    }
}

// Concrete Component 2
class Checkbox extends BaseComponent {
    check() {
        console.log("Checkbox checked.");
        this.mediator.notify(this, "check");
    }
}

// Concrete Mediator
class AuthenticationDialog implements Mediator {
    notify(sender: object, event: string): void {
        if (event === "click") {
            console.log("Mediator reacts to click: Validating...");
        }
        if (event === "check") {
            console.log("Mediator reacts to check: Updating UI...");
        }
    }
}
```

## 4. Pros and Cons

| Pros | Cons |
| :--- | :--- |
| **SRP:** You can extract the communications between various components into a single place. | **God Object:** The mediator can evolve into a God Object that knows too much and is hard to maintain. |
| **Decoupling:** Components don't depend on each other, only on the mediator. | |
| **Reuse:** You can reuse individual components more easily because they don't depend on specific other components. | |

[[programming/design-patterns]]
[[programming/object-oriented-programming]]