const EventEmitter = require('events');
const myEmitter = new EventEmitter();
 
// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});
 
console.log(myEmitter.listeners('event'));
 
myEmitter.emit('event', 1, 2, 3, 4, 5);
 
// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener

const EventEmitter = require('events');
const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});
 
const sym = Symbol('symbol');
myEE.on(sym, () => {});
 
console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]

server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});

server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));
 
// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];
 
// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();
 
// Logs "log once" to the console and removes the listener
logFnWrapper();
 
emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');
 
// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');

const callback = (stream) => {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);

const myEmitter = new MyEmitter();
 
const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};
 
const callbackB = () => {
  console.log('B');
};
 
myEmitter.on('event', callbackA);
 
myEmitter.on('event', callbackB);
 
// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B
 
// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A

const ee = new EventEmitter();
 
function pong() {
  console.log('pong');
}
 
ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);
 
ee.emit('ping');
ee.emit('ping');

const { getEventListeners, EventEmitter } = require('events');
 
{
  const ee = new EventEmitter();
  const listener = () => console.log('Events are fun');
  ee.on('foo', listener);
  getEventListeners(ee, 'foo'); // [listener]
}
{
  const et = new EventTarget();
  const listener = () => console.log('Events are fun');
  et.addEventListener('foo', listener);
  getEventListeners(et, 'foo'); // [listener]
}

const { EventEmitter, listenerCount } = require('events');
const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2

const { on, EventEmitter } = require('events');
 
(async () => {
  const ee = new EventEmitter();
 
  // Emit later on
  process.nextTick(() => {
    ee.emit('foo', 'bar');
    ee.emit('foo', 42);
  });
 
  for await (const event of on(ee, 'foo')) {
    // The execution of this inner block is synchronous and it
    // processes one event at a time (even with await). Do not use
    // if concurrent execution is required.
    console.log(event); // prints ['bar'] [42]
  }
  // Unreachable here
})();

const { on, EventEmitter } = require('events');
const ac = new AbortController();
 
(async () => {
  const ee = new EventEmitter();
 
  // Emit later on
  process.nextTick(() => {
    ee.emit('foo', 'bar');
    ee.emit('foo', 42);
  });
 
  for await (const event of on(ee, 'foo', { signal: ac.signal })) {
    // The execution of this inner block is synchronous and it
    // processes one event at a time (even with await). Do not use
    // if concurrent execution is required.
    console.log(event); // prints ['bar'] [42]
  }
  // Unreachable here
})();
 
process.nextTick(() => ac.abort());

const { once, EventEmitter } = require('events');
 
async function run() {
  const ee = new EventEmitter();
 
  process.nextTick(() => {
    ee.emit('myevent', 42);
  });
 
  const [value] = await once(ee, 'myevent');
  console.log(value);
 
  const err = new Error('kaboom');
  process.nextTick(() => {
    ee.emit('error', err);
  });
 
  try {
    await once(ee, 'myevent');
  } catch (err) {
    console.log('error happened', err);
  }
}
 
run();

const { EventEmitter, once } = require('events');
 
const ee = new EventEmitter();
 
once(ee, 'error')
  .then(([err]) => console.log('ok', err.message))
  .catch((err) => console.log('error', err.message));
 
ee.emit('error', new Error('boom'));
 
// Prints: ok boom

const { EventEmitter, once } = require('events');
 
const ee = new EventEmitter();
const ac = new AbortController();
 
async function foo(emitter, event, signal) {
  try {
    await once(emitter, event, { signal });
    console.log('event emitted!');
  } catch (error) {
    if (error.name === 'AbortError') {
      console.error('Waiting for the event was canceled!');
    } else {
      console.error('There was an error', error.message);
    }
  }
}
 
foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!

const {
  setMaxListeners,
  EventEmitter
} = require('events');
 
const target = new EventTarget();
const emitter = new EventEmitter();
 
setMaxListeners(5, target, emitter);