maksims / mr-eventemitter

Provides the ability to subscribe and emit events in sync manner. With a focus on performance and memory efficiency.

mr-EventEmitter

Provides ability to subscribe and emit events. This event emitter is tailored for real-time applications so is designed with performance and memory efficiency in mind.
Also it has two build targets: ES5 (ECMA2009) and ES8+ (modern JS), to maximize browser support without sacrificing benefits of modern JS for majority of users.

🚀 Install

Node.js

Install:

npm install mr-eventemitter

In code:

const EventEmitter = require('mr-eventemitter');

Browser

<script type='module' src='mr-eventemitter.min.js'></script>
<script nomodule src='mr-eventemitter.es5.min.js'></script>

Use built files from a dist directory for the browser. It will load ES8+ version if it is supported (~94%), otherwise it will load ES5 (ECMA2009) version that supports pretty much every platform.

CDN (jsDelivr)

You can use a public CDN for the library:

ES8+ module: https://cdn.jsdelivr.net/npm/[email protected]/dist/mr-eventemitter.min.js
ES5 version: https://cdn.jsdelivr.net/npm/[email protected]/dist/mr-eventemitter.es5.min.js

Example

let obj = new EventEmitter();

obj.on('event', (a) => {
    console.log('event', a);
});

obj.emit('event', 42);

📜 API Documentation

Usage

Creating:

Creating event emitter directly:

let obj = new EventEmitter();

With class:

class World extends EventEmitter {
    contrunctor() {
        super();
    }
}

With prototype:

function World() {
    EventEmitter.call(this);
}
World.prototype = Object.create(EventEmitter.prototype);
World.prototype.constructor = World;

Emitting:

obj.emit('event', 42);

Or with many arguments:

obj.emit('event', 4, 8, 16, 32);

Subscribing:

obj.on('event', function(value) {
    console.log('event', value);
});

It is possible to pass to an event many arguments:

obj.on('event', function(a, b, c, d) {
    console.log('event', a, b, c, d);
});

For single life event use once:

obj.once('event', function(value) {
    console.log('event', value);
});

Sometimes providing scope for a callback function is usefull:

class Place {
    constructor() {
        this.name = 'Home';

        world.on('event', function() {
            // this - will be this `Place` instead of `world`
            console.log('event', this.name); // hello Home
        }, this); // - notice `this`
    }
}

Removing events:

To remove event handler, you can use off method on EventEmitter:

obj.off('event', fn);

To remove all events by name:

obj.off('event');

Remove a group of events, that match a regular expression:

obj.off(/input:\w+/);

obj.emit('init');
obj.emit('input:start');    // ignored
obj.emit('input:end');      // ignored

To remove all events:

obj.off();

And for easier management, on and once methods return EventHandler, which then can be used for removing events:

let evt = obj.on('event', (value) => {
    console.log('event', value);
});

evt.off();

Building

Builds a single file into two ES5 and ES8+ versions using Babel and Terser.
Source file: src/index.js
Built versions ES5 (dist/mr-eventemitter.es5.min.js) and ES8+ (dist/mr-eventemitter.min.js):

npm install
npm run build

mr-eventemitter's Issues

Do not clone callbacks Set unless there is attempt to modify it

For efficiency on memory, is is important to avoid allocations as much as possible.
Currently there is allocation (copy of a Set) on each emit of callback.
It is possible to do copy of Set only if there is any attempt to modify it during callback execution. In majority of cases this will avoid allocation, for the small cost of CPU for checks on modification attempts.