jsdoc/packages/jsdoc-util/lib/bus.js

const _ = require('lodash');
const EventEmitter = require('events').EventEmitter;
const { default: ow } = require('ow');

let cache = {};
const hasOwnProp = Object.prototype.hasOwnProperty;

/**
 * An event bus that works the same way as a standard Node.js event emitter, with a few key
 * differences:
 *
 * + When you create an event bus, you must specify its name. Consider using your package's name.
 * + Event buses are cached and shared by default. If module A and module B both create an event bus
 * called `foo`, both modules get the same event bus. This behavior makes it easier to share one
 * event bus among all of the modules in your package.
 *
 *     To prevent a new event bus from being cached and shared, set the `opts.cache` property to
 *     `false` when you create the event bus. Setting this property to `false` also forces a new
 *     event bus to be created, even if there's a cached event bus with the same name.
 *
 * @alias module:@jsdoc/util.EventBus
 * @extends module:events.EventEmitter
 */
class EventBus extends EventEmitter {
  /**
   * Create a new event bus, or retrieve the cached event bus for the ID you specify.
   *
   * @param {(string|Symbol)} id - The ID for the event bus.
   * @param {Object} opts - Options for the event bus.
   * @param {boolean} [opts.cache=true] - Set to `false` to prevent the event bus from being
   * cached, and to return a new event bus even if there is already an event bus with the same ID.
   */
  constructor(id, opts = {}) {
    super();

    ow(id, ow.any(ow.string, ow.symbol));

    const shouldCache = _.isBoolean(opts.cache) ? opts.cache : true;

    if (hasOwnProp.call(cache, id) && shouldCache) {
      return cache[id];
    }

    this._id = id;

    if (shouldCache) {
      cache[id] = this;
    }
  }
}

module.exports = EventBus;