Type safe event emitter with wildcard listeners

Medium

You need to implement a type-safe event emitter that supports wildcard listeners. Which implementation correctly handles all the edge cases?

Choose an option below

on(event, callback) {
  if (event.includes('*')) {
    this.wildcards.add(callback);
  } else {
    if (!this.events.has(event)) {
      this.events.set(event, new Set());
    }
    this.events.get(event).add(callback);
  }
}

emit(event, data) {
  const listeners = this.events.get(event);
  if (listeners) {
    listeners.forEach(callback => callback(data));
  }
  this.wildcards.forEach(callback => callback(event, data));
}

on(pattern, callback) {
  if (pattern.includes('*')) {
    this.wildcards.add({
      pattern: new RegExp('^' + pattern.replace('*', '.*') + '$'),
      callback
    });
  } else {
    if (!this.events.has(pattern)) {
      this.events.set(pattern, new Set());
    }
    this.events.get(pattern).add(callback);
  }
}

emit(event, data) {
  if (this.events.has(event)) {
    this.events.get(event).forEach(callback => callback(data));
  }
  
  this.wildcards.forEach(({ pattern, callback }) => {
    if (pattern.test(event)) {
      callback(event, data);
    }
  });
}

on(event, callback) {
  const events = event.split('*');
  if (events.length > 1) {
    this.wildcards.add({
      prefix: events[0],
      suffix: events[1],
      callback
    });
  } else {
    if (!this.events.has(event)) {
      this.events.set(event, []);
    }
    this.events.get(event).push(callback);
  }
}

emit(event, data) {
  (this.events.get(event) || []).forEach(cb => cb(data));
  this.wildcards.forEach(({ prefix, suffix, callback }) => {
    if (event.startsWith(prefix) &amp;&amp; event.endsWith(suffix)) {
      callback(event, data);
    }
  });
}

on(eventPattern, listener) {
  const callbacks = this.events.get(eventPattern) || new Set();
  callbacks.add(listener);
  this.events.set(eventPattern, callbacks);
}

emit(event, data) {
  this.events.forEach((listeners, pattern) => {
    if (pattern === event || pattern.includes('*')) {
      listeners.forEach(callback => callback(data));
    }
  });
}

JavascriptEventsPatternsRegexpWildcards

1class EventEmitter {
2  constructor() {
3    this.events = new Map();
4    this.wildcards = new Set();
5  }
6
7  // Missing implementation
8  ____________________
9  ____________________
10  ____________________
11  ____________________
12}
13
14// Usage:
15const emitter = new EventEmitter();
16
17emitter.on('user:*', (event, data) => {
18  console.log(`User event: ${event}`, data);
19});
20
21emitter.on('user:login', (data) => {
22  console.log('User logged in:', data);
23});
24
25emitter.emit('user:login', { id: 1, name: 'John' });

You need to implement a type-safe event emitter that supports wildcard listeners. Which implementation correctly handles all the edge cases?

Hint