simple-event-machine/README.md

A simple event machine

# 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:
```javascript
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<](https://nodejs.org/) 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)