simple-event-machine

What is simple-event-machine?

simple-event-machine is a node.js library to easily setup an event machine.

How does it work?

One possible implementation could be:

var eventmachine = new require('simple-event-machine').Instance();
// OR (as instantiation is optional)
// var eventmachine = require('simple-event-machine');
 
// You can always create a new eventmachine instance by calling
var newEventmachine = new eventmachine.Instance();
// This will work on all instances of eventmachine. Thus:
var yetAnotherEventmachine = new newEventmachine.Instance();
// will yield another - independent - instance.
// You can also inject simple-event-machine into existing Objects
var exoticEventmachine = {
  foo: function(payload, eventname) {
    console.log(eventname, payload, 'from exoticEventmachine');
  }
};
new eventmachine.Instance(exoticEventmachine);
 
//But after all, you don't need to call the constructor, if you don't want to.
eventmachine.on('*', console.log); // 1st parameter: payload, 2nd parameter: event-name
newEventmachine.on('*', console.log); // event-name '*' listens on all events
exoticEventmachine.on('*', exoticEventmachine.foo); // event-name '*' listens on all events
eventmachine.on('error', console.error); //same as above. where 'error' is the event-name
 
eventmachine.emit('event-name', {"this is": "my payload"});
newEventmachine.emit('newEventmachine', {"payload": "will output"});
yetAnotherEventmachine.emit('yetAnotherEventmachine', {"payload": "will not output as there is no consumer"});
exoticEventmachine.emit('exoticEventmachine', {"payload": "will output"});
eventmachine.emit('error', {"this is": "my error"});

Installation

To install you need to:

• Perform a npm install simple-event-machine --save
• implement as above
• You're done!

(You will need >node.js< of course)

Method Signature

emit({string} eventName, {Object} payload)

• Emit a new event with the name <eventName> and <payload> as payload.

on({string} eventName, {function(Object, string): void} callback)

• Register <callback> as a new consumer for <eventName>. <callback> will be called with <payload, eventName>.
• If <eventName> is *, listen for all events.

new Instance({Object=} me) constructor

• available in each instance. Will return a new independent instance or (<me> if specified).
• if <me> is specified emit, on and Instance will be injected into that object. (optional)