The EventEmitter

// A small emitter with the rules of EventEmitter's on, once, off and emit.
export function createEmitter() {
  const listeners = new Map(); // event name -> array of functions

  function on(name, fn) {
    if (!listeners.has(name)) listeners.set(name, []);
    listeners.get(name).push(fn);
  }

  function off(name, fn) {}

  function once(name, fn) {
    on(name, fn);
  }

  function emit(name, ...args) {
    for (const fn of listeners.get(name) ?? []) fn();
  }

  return {on, once, off, emit};
}

const door = createEmitter();
door.on('open', (who) => console.log('hello', who));
door.once('open', () => console.log('first visitor'));
console.log(door.emit('open', 'Ada'), door.emit('open', 'Lin'), door.emit('close'));

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {createEmitter} from './main.js';

test('listeners run in the order they were added, with the arguments of emit', () => {
  const e = createEmitter();
  const seen = [];
  e.on('sale', (item, price) => seen.push('first ' + item + ' ' + price));
  e.on('sale', (item) => seen.push('second ' + item));
  e.emit('sale', 'tea', 3);
  assert.deepEqual(seen, ['first tea 3', 'second tea'], `the listeners saw ${JSON.stringify(seen)}`);
});

test('emit returns true with listeners and false without', () => {
  const e = createEmitter();
  e.on('sale', () => {});
  assert.equal(e.emit('sale'), true, 'emit for an event with a listener should return true');
  assert.equal(e.emit('refund'), false, 'emit for an event without listeners should return false');
});

test('off removes one instance of the function', () => {
  const e = createEmitter();
  let calls = 0;
  const count = () => calls++;
  e.on('ping', count);
  e.on('ping', count);
  e.off('ping', count);
  e.emit('ping');
  assert.equal(calls, 1, `count ran ${calls} times after two on and one off; expected 1`);
  e.off('ping', count);
  assert.equal(e.emit('ping'), false, 'after removing both instances, emit should return false');
});

test('a once listener runs on the next emit only', () => {
  const e = createEmitter();
  let calls = 0;
  e.once('ring', (n) => (calls += n));
  assert.equal(e.emit('ring', 5), true, 'the first emit should find the once listener');
  assert.equal(e.emit('ring', 5), false, 'the second emit should find no listener');
  assert.equal(calls, 5, `the once listener added up to ${calls}; expected 5`);
});

test('a listener that removes itself does not make the next one be skipped', () => {
  const e = createEmitter();
  const seen = [];
  const first = () => {
    seen.push('first');
    e.off('open', first);
  };
  e.on('open', first);
  e.on('open', () => seen.push('second'));
  e.emit('open');
  assert.deepEqual(seen, ['first', 'second'], `the listeners that ran were ${JSON.stringify(seen)}`);
});

{
  "type": "module"
}

import {EventEmitter} from 'node:events';

// A kettle that reports what it does as events.
export class Kettle extends EventEmitter {
  constructor() {
    super();
    this.temperature = 20;
  }

  // Heats in steps of 20 degrees up to target, with a 'temperature' event for each
  // new value, then 'boiled' at 100. Above 100: an 'error' event, and no heating.
  heat(target) {
    this.temperature = target;
  }
}

const kettle = new Kettle();
kettle.on('temperature', (degrees) => console.log(degrees + ' degrees'));
kettle.once('boiled', () => console.log('boiled'));
kettle.on('error', (error) => console.log('error:', error.message));
kettle.heat(100);
kettle.heat(120);

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {Kettle} from './main.js';

test('heat(80) emits temperature 40, 60 and 80', () => {
  const kettle = new Kettle();
  const seen = [];
  kettle.on('temperature', (degrees) => seen.push(degrees));
  kettle.heat(80);
  assert.deepEqual(seen, [40, 60, 80], `the temperature events were ${JSON.stringify(seen)}`);
});

test('steps never go past the target', () => {
  const kettle = new Kettle();
  const seen = [];
  kettle.on('temperature', (degrees) => seen.push(degrees));
  kettle.heat(50);
  assert.deepEqual(seen, [40, 50], `the temperature events were ${JSON.stringify(seen)}`);
});

test('boiled is emitted once, when 100 is reached', () => {
  const kettle = new Kettle();
  let boiled = 0;
  kettle.on('boiled', () => boiled++);
  kettle.heat(60);
  assert.equal(boiled, 0, 'boiled should not be emitted at 60 degrees');
  kettle.heat(100);
  assert.equal(boiled, 1, `boiled was emitted ${boiled} times; expected 1`);
});

test('above 100, an error event with a RangeError, and no heating', () => {
  const kettle = new Kettle();
  const errors = [];
  kettle.on('error', (error) => errors.push(error));
  kettle.heat(120);
  assert.equal(errors.length, 1, `there were ${errors.length} error events; expected 1`);
  assert.ok(errors[0] instanceof RangeError, 'the error event should carry a RangeError');
  assert.equal(kettle.temperature, 20, `the temperature is ${kettle.temperature}; it should stay 20`);
});

test('without an error listener, heat(120) throws the RangeError', () => {
  assert.throws(() => new Kettle().heat(120), RangeError, 'heat(120) with no error listener should throw a RangeError');
});

{
  "type": "module"
}