ts-04-event-emitter

# Typed event emitter

Implement **`solution.ts`** exporting a generic, fully typed event emitter:

```ts
export class EventEmitter<Events extends Record<string, unknown[]>> {
  on<E extends keyof Events>(event: E, fn: (...args: Events[E]) => void): () => void;
  off<E extends keyof Events>(event: E, fn: (...args: Events[E]) => void): void;
  emit<E extends keyof Events>(event: E, ...args: Events[E]): void;
}
```

`Events` maps an event name to the **tuple of argument types** its listeners receive.

- `on(event, fn)` registers a listener and returns an **unsubscribe** function. Calling
  the returned function removes that exact listener.
- `off(event, fn)` removes a previously registered listener. Removing a listener that is
  not registered is a no-op.
- `emit(event, ...args)` calls every listener registered for `event`, **in the order they
  were registered**, passing `args`. Emitting an event with no listeners is a no-op.
- The same function may be registered more than once; each registration is independent.

Example:

```ts
type Events = {
  message: [text: string];
  count: [n: number, label: string];
};

const ee = new EventEmitter<Events>();
const unsub = ee.on("message", (text) => console.log(text));
ee.emit("message", "hi"); // logs "hi"
unsub();
ee.emit("message", "bye"); // nothing logged
```

Keep it fully typed (must pass `tsc --noEmit` in strict mode). Do not use `any` in the
public API.

import { test } from "node:test";
import { strict as assert } from "node:assert";
import { EventEmitter } from "./solution.ts";

type Events = {
  message: [text: string];
  count: [n: number, label: string];
};

test("calls a registered listener with args", () => {
  const ee = new EventEmitter<Events>();
  const seen: string[] = [];
  ee.on("message", (text) => seen.push(text));
  ee.emit("message", "hi");
  assert.deepEqual(seen, ["hi"]);
});

test("multiple listeners fire in registration order", () => {
  const ee = new EventEmitter<Events>();
  const order: number[] = [];
  ee.on("message", () => order.push(1));
  ee.on("message", () => order.push(2));
  ee.on("message", () => order.push(3));
  ee.emit("message", "x");
  assert.deepEqual(order, [1, 2, 3]);
});

test("passes multiple typed args", () => {
  const ee = new EventEmitter<Events>();
  let received: [number, string] | undefined;
  ee.on("count", (n, label) => {
    received = [n, label];
  });
  ee.emit("count", 7, "items");
  assert.deepEqual(received, [7, "items"]);
});

test("returned unsubscribe removes the listener", () => {
  const ee = new EventEmitter<Events>();
  const seen: string[] = [];
  const unsub = ee.on("message", (t) => seen.push(t));
  ee.emit("message", "a");
  unsub();
  ee.emit("message", "b");
  assert.deepEqual(seen, ["a"]);
});

test("off removes a specific listener, leaving others", () => {
  const ee = new EventEmitter<Events>();
  const seen: string[] = [];
  const a = (t: string) => seen.push("a:" + t);
  const b = (t: string) => seen.push("b:" + t);
  ee.on("message", a);
  ee.on("message", b);
  ee.off("message", a);
  ee.emit("message", "x");
  assert.deepEqual(seen, ["b:x"]);
});

test("emitting an event with no listeners is a no-op", () => {
  const ee = new EventEmitter<Events>();
  assert.doesNotThrow(() => ee.emit("message", "nobody"));
});

test("off on an unregistered listener is a no-op", () => {
  const ee = new EventEmitter<Events>();
  assert.doesNotThrow(() => ee.off("message", () => {}));
});

test("the same function registered twice fires twice", () => {
  const ee = new EventEmitter<Events>();
  let calls = 0;
  const fn = () => {
    calls += 1;
  };
  ee.on("message", fn);
  ee.on("message", fn);
  ee.emit("message", "x");
  assert.equal(calls, 2);
});

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

To solve this problem, we need to implement a generic, fully typed event emitter in TypeScript. The event emitter should allow registering listeners for specific events, removing listeners, and emitting events with arguments. Each event has a defined set of argument types that listeners expect.

### Approach
The solution involves creating an `EventEmitter` class that uses a private map to store listeners for each event. The class provides three main methods: `on`, `off`, and `emit`.

1. **on(event, fn)**: This method registers a listener function for a specific event and returns an unsubscribe function. The unsubscribe function removes the listener when called.
2. **off(event, fn)**: This method removes a previously registered listener for a specific event. If the listener is not found, it does nothing.
3. **emit(event, ...args)**: This method emits an event, calling all registered listeners for that event in the order they were registered, passing the provided arguments.

The class uses an internal map (`_listeners`) where each key is an event name and the value is an array of listener functions. This ensures that listeners are stored and managed efficiently.

### Solution Code
```typescript
export class EventEmitter<Events extends Record<string, unknown[]>> {
  private _listeners: { [event: string]: Function[] } = {};

  on<E extends keyof Events>(event: E, fn: (...args: Events[E]) => void): () => void {
    if (!this._listeners[event]) {
      this._listeners[event] = [];
    }
    this._listeners[event].push(fn);
    return () => {
      const index = this._listeners[event].indexOf(fn);
      if (index !== -1) {
        this._listeners[event].splice(index, 1);
      }
    };
  }

  off<E extends keyof Events>(event: E, fn: (...args: Events[E]) => void): void {
    if (this._listeners[event]) {
      const index = this._listeners[event].indexOf(fn);
      if (index !== -1) {
        this._listeners[event].splice(index, 1);
      }
    }
  }

  emit<E extends keyof Events>(event: E, ...args: Events[E]): void {
    if (this._listeners[event]) {
      this._listeners[event].forEach(listener => {
        listener.apply(undefined, args);
      });
    }
  }
}
```

### Explanation
- **on Method**: This method adds a listener function to the array of listeners for the specified event. It returns an unsubscribe function that removes the listener when called. The listener is removed by finding its index in the array and splicing it out.
- **off Method**: This method removes a listener function from the array of listeners for the specified event. It uses `indexOf` to find the listener and removes it if found.
- **emit Method**: This method iterates over all listeners for the specified event and calls each listener with the provided arguments. If no listeners are registered for the event, it does nothing.

This implementation ensures that listeners are managed efficiently and correctly, adhering to the specified type constraints and behavior.

Okay, I need to implement a typed event emitter in TypeScript. The problem gives me the exact function signatures I need to follow, so I should make sure to stick to those.

First, looking at the class definition: it's an EventEmitter that takes a generic type Events, which is a record mapping event names to argument type tuples. So each event has a specific set of argument types that listeners expect.

The methods are on, off, and emit. Let's think about each one.

Starting with the on method. It should register a listener function and return an unsubscribe function. The unsubscribe function, when called, should remove that specific listener. So I need a way to store the listeners for each event. Maybe I'll have a private property, like listeners, which is a map from event names to an array of functions. Each function is wrapped in an object that includes its index so we can remove it efficiently.

Wait, but functions are compared by reference, so when a user calls off, we need to find the exact function in the listeners array. So for each event, I'll store an array of functions. When on is called, I push the function into the array and return a function that removes it by finding its index.

But how do I handle the removal? Because when you have multiple listeners added with the same function, each on call adds a new entry. So when unsub is called, it should remove only that specific registration.

So for the on method:
- When a new listener is added, push it into the listeners array for that event.
- Return a function that, when called, removes that specific listener from the array.

Next, the off method. It takes the event and the function, and removes it from the listeners. But if the function isn't found, it does nothing. So I need to loop through the listeners for that event and find the index where the function matches, then splice it out.

The emit method is next. It should call all listeners for the given event in the order they were registered, passing the arguments. So for emit, I check if the event exists in the listeners map. If it does, I iterate over each listener function and call it with the provided arguments.

Now, thinking about the private properties. I'll need a private map, maybe called _listeners, which is a Map where each key is an event name, and the value is an array of listener functions.

Wait, but in TypeScript, using a Map might be more efficient, but since the events are string keys, perhaps a regular object with each event as a property, and each property's value is an array of functions. So something like:

private _listeners: { [event: string]: Function[] } = {};

But wait, in TypeScript, using an interface for this might be better. Alternatively, I can initialize it as an empty object and then check if the event exists before adding listeners.

So, for the on method:
- Check if the event exists in _listeners. If not, create an empty array.
- Push the new function into the array.
- Return a function that removes this function from the array.

For off:
- Check if the event exists. If not, do nothing.
- If it exists, loop through the functions in the array and find the one that matches the given fn. Remove it by index.

But wait, functions are objects, so comparing them with === should work since each function is a unique object unless they are the same function reference.

Wait, but in the example, the same function can be registered multiple times. So each on call adds a new entry, even if the function is the same. So when off is called with that function, it should remove only one occurrence. So in the off method, we need to find the first occurrence of the function and remove it.

Alternatively, perhaps the off method should remove all occurrences of that function. But according to the problem statement, the off method removes a previously registered listener. So if the same function was added multiple times, each on call returns an unsub function that removes only that specific registration.

Wait, no. The on method returns an unsubscribe function that, when called, removes the listener that was just added. So each on call adds a new listener, and the unsub function removes only that one.

So in the on method, when you add a new listener, you return a function that, when called, removes that specific listener from the array.

So for the on method:

function on<E extends keyof Events>(event: E, fn: (...args: Events[E]) => void) {
  if (!this._listeners[event]) {
    this._listeners[event] = [];
  }
  this._listeners[event].push(fn);
  return () => {
    const index = this._listeners[event].indexOf(fn);
    if (index !== -1) {
      this._listeners[event].splice(index, 1);
    }
  };
}

Wait, but indexOf might not be efficient for large arrays, but for the purposes of this problem, it's acceptable.

Now, the off method:

function off<E extends keyof Events>(event: E, fn: (...args: Events[E]) => void) {
  if (this._listeners[event]) {
    const index = this._listeners[event].indexOf(fn);
    if (index !== -1) {
      this._listeners[event].splice(index, 1);
    }
  }
}

But wait, what if the event doesn't exist in _listeners? Then it's a no-op, which is correct.

For the emit method:

function emit<E extends keyof Events>(event: E, ...args: Events[E]) {
  if (this._listeners[event]) {
    this._listeners[event].forEach(listener => {
      listener.apply(undefined, args);
    });
  }
}

Wait, but in TypeScript, when you have a function that expects certain arguments, you need to make sure that the arguments passed match. But since the emit is typed with ...args: Events[E], which is the tuple, the function expects the correct number and types of arguments.

So, putting it all together.

Now, considering edge cases:

- What if emit is called with an event that has no listeners? Then it's a no-op, which is correct.

- What if the same function is added multiple times via on? Each on call adds a new entry, so each will have their own unsub function. So when you call unsub, it removes only that specific registration.

Testing the example:

type Events = { message: [string]; count: [number, string] 
…[1404 chars elided]…
, iterate over each listener for the event and call them with the arguments.

Now, writing the code.

First, the class:

export class EventEmitter<Events extends Record<string, unknown[]>> {
  private _listeners: { [event: string]: Function[] } = {};

  on<E extends keyof Events>(event: E, fn: (...args: Events[E]) => void): () => void {
    if (!this._listeners[event]) {
      this._listeners[event] = [];
    }
    this._listeners[event].push(fn);
    return () => {
      const index = this._listeners[event].indexOf(fn);
      if (index !== -1) {
        this._listeners[event].splice(index, 1);
      }
    };
  }

  off<E extends keyof Events>(event: E, fn: (...args: Events[E]) => void): void {
    if (this._listeners[event]) {
      const index = this._listeners[event].indexOf(fn);
      if (index !== -1) {
        this._listeners[event].splice(index, 1);
      }
    }
  }

  emit<E extends keyof Events>(event: E, ...args: Events[E]): void {
    if (this._listeners[event]) {
      this._listeners[event].forEach(listener => {
        listener.apply(undefined, args);
      });
    }
  }
}

Wait, but in TypeScript, when you have a function that expects certain arguments, using apply with the correct number of args is okay. But in the on and off methods, the functions are typed to accept exactly the arguments in Events[E], so when emit is called with the correct ...args, it should work.

Testing this code with the example should work.

But wait, in the on method, the function is stored as a Function, but in TypeScript, functions are compared by reference. So if the same function is added multiple times, each on call adds a new reference, and each unsub removes only that specific reference.

Yes, that's correct.

Another thing to consider: what if someone passes a function that is not compatible with the event's argument types? The type system should catch that at compile time, so during runtime, it's up to the user to provide correct arguments.

So the code should be correct.

I think this should solve the problem.