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.

```ts
export class EventEmitter<Events extends Record<string, unknown[]>> {
  private listeners: Map<keyof Events, Set<(...args: Events[keyof Events]) => void>> = new Map();

  on<E extends keyof Events>(event: E, fn: (...args: Events[E]) => void): () => void {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, new Set());
    }
    const set = this.listeners.get(event)!;
    set.add(fn);
    return () => this.off(event, fn);
  }

  off<E extends keyof Events>(event: E, fn: (...args: Events[E]) => void): void {
    const set = this.listeners.get(event);
    if (set) {
      set.delete(fn);
    }
  }

  emit<E extends keyof Events>(event: E, ...args: Events[E]): void {
    const set = this.listeners.get(event);
    if (set) {
      for (const fn of set) {
        fn(...args);
      }
    }
  }
}
```

[
  {
    "total": 8,
    "answer": "```ts\nexport class EventEmitter<Events extends Record<string, unknown[]>> {\n  private listeners: Map<keyof Events, Set<(...args: Events[keyof Events]) => void>> = new Map();\n\n  on<E extends keyof Events>(event: E, fn: (...args: Events[E]) => void): () => void {\n    if (!this.listeners.has(event)) {\n      this.listeners.set(event, new Set());\n    }\n    const set = this.listeners.get(event)!;\n    set.add(fn);\n    return () => this.off(event, fn);\n  }\n\n  off<E extends keyof Events>(event: E, fn: (...args: Events[E]) => void): void {\n    const set = this.listeners.get(event);\n    if (set) {\n      set.delete(fn);\n    }\n  }\n\n  emit<E extends keyof Events>(event: E, ...args: Events[E]): void {\n    const set = this.listeners.get(event);\n    if (set) {\n      for (const fn of set) {\n        fn(...args);\n      }\n    }\n  }\n}\n```",
    "passed": 7,
    "test_error": "TAP version 13\n# Subtest: calls a registered listener with args\nok 1 - calls a registered listener with args\n  ---\n  duration_ms: 0.623074\n  type: 'test'\n  ...\n# Subtest: multiple listeners fire in registration order\nok 2 - multiple listeners fire in registration order\n  ---\n  duration_ms: 0.077791\n  type: 'test'\n  ...\n# Subtest: passes multiple typed args\nok 3 - passes multiple typed args\n  ---\n  duration_ms: 0.04992\n  type: 'test'\n  ...\n# Subtest: returned unsubscribe removes the listener\nok 4 - returned unsubscribe removes the listener\n  ---\n  duration_ms: 0.051061\n  type: 'test'\n  ...\n# Subtest: off removes a specific listener, leaving others\nok 5 - off removes a specific listener, leaving others\n  ---\n  duration_ms: 0.0729\n  type: 'test'\n  ...\n# Subtest: emitting an event with no listeners is a no-op\nok 6 - emitting an event with no listeners is a no-op\n  ---\n  duration_ms: 0.078331\n  type: 'test'\n  ...\n# Subtest: off on an unregistered listener is a no-op\nok 7 - off on an unregistered listener is a no-op\n  ---\n  duration_ms: 0.0403\n  type: 'test'\n  ...\n# Subtest: the same function registered twice fires twice\nnot ok 8 - the same function registered twice fires twice\n  ---\n  duration_ms: 0.839216\n  type: 'test'\n  location: '/tmp/llmlab-ts-04-event-emitter-6sdffn_9/solution.test.ts:1:1657'\n  failureType: 'testCodeFailure'\n  error: |-\n    Expected values to be strictly equal:\n    \n    1 !== 2\n    \n  code: 'ERR_ASSERTION'\n  name: 'AssertionError'\n  expected: 2\n  actual: 1\n  operator: 'strictEqual'\n  stack: |-\n    TestContext.<anonymous> (/tmp/llmlab-ts-04-event-emitter-6sdffn_9/solution.test.ts:79:10)\n    Test.runInAsyncScope (node:async_hooks:227:14)\n    Test.run (node:internal/test_runner/test:1306:25)\n    Test.processPendingSubtests (node:internal/test_runner/test:897:18)\n    Test.postRun (node:internal/test_runner/test:1447:19)\n    Test.run (node:internal/test_runner/test:1372:12)\n    async Test.processPendingSubtests (node:internal/test_runner/test:897:7)\n  ...\n1..8\n# tests 8\n# suites 0\n# pass 7\n# fail 1\n# cancelled 0\n# skipped 0\n# todo 0\n# duration_ms 77.842517"
  },
  {
    "total": 8,
    "answer": "```ts\nexport class EventEmitter<Events extends Record<string, unknown[]>> {\n  private listeners: Map<keyof Events, Set<(...args: Events[keyof Events]) => void>> = new Map();\n\n  on<E extends keyof Events>(event: E, fn: (...args: Events[E]) => void): () => void {\n    if (!this.listeners.has(event)) {\n      this.listeners.set(event, new Set());\n    }\n    const set = this.listeners.get(event)!;\n    set.add(fn);\n    return () => this.off(event, fn);\n  }\n\n  off<E extends keyof Events>(event: E, fn: (...args: Events[E]) => void): void {\n    const set = this.listeners.get(event);\n    if (set) {\n      set.delete(fn);\n    }\n  }\n\n  emit<E extends keyof Events>(event: E, ...args: Events[E]): void {\n    const set = this.listeners.get(event);\n    if (set) {\n      const fns = Array.from(set);\n      for (const fn of fns) {\n        fn(...args);\n      }\n    }\n  }\n}\n```",
    "passed": 7,
    "test_error": "TAP version 13\n# Subtest: calls a registered listener with args\nok 1 - calls a registered listener with args\n  ---\n  duration_ms: 0.626354\n  type: 'test'\n  ...\n# Subtest: multiple listeners fire in registration order\nok 2 - multiple listeners fire in registration order\n  ---\n  duration_ms: 0.07527\n  type: 'test'\n  ...\n# Subtest: passes multiple typed args\nok 3 - passes multiple typed args\n  ---\n  duration_ms: 0.052141\n  type: 'test'\n  ...\n# Subtest: returned unsubscribe removes the listener\nok 4 - returned unsubscribe removes the listener\n  ---\n  duration_ms: 0.0524\n  type: 'test'\n  ...\n# Subtest: off removes a specific listener, leaving others\nok 5 - off removes a specific listener, leaving others\n  ---\n  duration_ms: 0.064821\n  type: 'test'\n  ...\n# Subtest: emitting an event with no listeners is a no-op\nok 6 - emitting an event with no listeners is a no-op\n  ---\n  duration_ms: 0.075631\n  type: 'test'\n  ...\n# Subtest: off on an unregistered listener is a no-op\nok 7 - off on an unregistered listener is a no-op\n  ---\n  duration_ms: 0.0395\n  type: 'test'\n  ...\n# Subtest: the same function registered twice fires twice\nnot ok 8 - the same function registered twice fires twice\n  ---\n  duration_ms: 0.866456\n  type: 'test'\n  location: '/tmp/llmlab-ts-04-event-emitter-iu_mo78m/solution.test.ts:1:1657'\n  failureType: 'testCodeFailure'\n  error: |-\n    Expected values to be strictly equal:\n    \n    1 !== 2\n    \n  code: 'ERR_ASSERTION'\n  name: 'AssertionError'\n  expected: 2\n  actual: 1\n  operator: 'strictEqual'\n  stack: |-\n    TestContext.<anonymous> (/tmp/llmlab-ts-04-event-emitter-iu_mo78m/solution.test.ts:79:10)\n    Test.runInAsyncScope (node:async_hooks:227:14)\n    Test.run (node:internal/test_runner/test:1306:25)\n    Test.processPendingSubtests (node:internal/test_runner/test:897:18)\n    Test.postRun (node:internal/test_runner/test:1447:19)\n    Test.run (node:internal/test_runner/test:1372:12)\n    async Test.processPendingSubtests (node:internal/test_runner/test:897:7)\n  ...\n1..8\n# tests 8\n# suites 0\n# pass 7\n# fail 1\n# cancelled 0\n# skipped 0\n# todo 0\n# duration_ms 79.78887"
  },
  {
    "total": 8,
    "answer": "```ts\nexport class EventEmitter<Events extends Record<string, unknown[]>> {\n  private listeners: Map<keyof Events, Array<(...args: Events[keyof Events]) => void>> = new Map();\n\n  on<E extends keyof Events>(event: E, fn: (...args: Events[E]) => void): () => void {\n    if (!this.listeners.has(event)) {\n      this.listeners.set(event, []);\n    }\n    const arr = this.listeners.get(event)!;\n    arr.push(fn);\n    return () => this.off(event, fn);\n  }\n\n  off<E extends keyof Events>(event: E, fn: (...args: Events[E]) => void): void {\n    const arr = this.listeners.get(event);\n    if (arr) {\n      const index = arr.indexOf(fn);\n      if (index !== -1) {\n        arr.splice(index, 1);\n      }\n    }\n  }\n\n  emit<E extends keyof Events>(event: E, ...args: Events[E]): void {\n    const arr = this.listeners.get(event);\n    if (arr) {\n      for (const fn of arr) {\n        fn(...args);\n      }\n    }\n  }\n}\n```",
    "passed": 8,
    "test_error": ""
  }
]