Awesome

#network.js

API for arbitrary Network implementations between clients (Peer-to-Peer).

<head>
    ...
    <script src="your/path/network.bundle.js"></script>
    <script src="...jquery.js"></script>
    ...
    ...
    <body>
        ...
    </body>
    <script>
        $(function(){
            
            // e.g. Cyclon)
            var cyclon = new Cyclon(..);
            var vv = new VVBroadcastDefinition(..);
            
            var network = Network.init({
                membership : cyclon,
                broadcastDefinition: vv
            });
            
            network.ready(function(){
                // when we get this callback the program is ready to 
                // communicate!
            });
            
            //TODO: we need to do the handshake
        });
    <script>
</head>

The API needs implementations of the following interfaces:

##Interface: BroadcastDefinition

###stopPropagation gets called when a broadcast message reaches this node. This function evaluates if the node should propagate the message further or if it should stop sending it. This is defined by either returning {true} (Stop) or {false} (Keep propagating)

...
MyBroadcastDefinition.prototype.stopPropagation = function(message) {
    // the message is decorated!
    var doIKnowTheMessage = doIKnow(message.MY_MSG_ID); // depends on your implementation
    return doIKnowTheMessage;
}

###decorateBroadcastMessage before a message is broadcast, it gets decorated by the Broadcast definition. Here we can add additional values. This function only gets called when a peer starts a NEW BROADCAST. It will not be called when a peer simply propagates another peers broadcast.

...
MyBroadcastDefinition.prototype.decorateBroadcastMessage = function(message){
    // Decorate the message so that we can figure out what message this is
    var newMessage = {
        MY_MSG_ID : generateMessageID(), // we must define this
        payload: message // piggyback the message
    }
    return newMessage;
}

###removeDecoration Remove the decoration of the message so that the application can interact with the broadcast message transparently. This gets called whenever a broadcast message hits a peer and is propagated to the application.

...
MyBroadcastDefinition.prototype.decorateBroadcastMessage = function(message){
    // we want to return the message in its "original" representation so that
    // this detection is hidden away from the application
    return message.payload;
}

##Interface: Membership

###launch (handshaking step 1) Starts the Handshaking. This must be done once to connect to the network. {launch} takes a callback as parameter that gets called when the ICE-Candidates are gathered. The {offer} that is created must be transmitted to the other peer (How this is done is out of the scope of this library) in order to initiate the handshake.

...
// onOffer is a function callback (parameter: string)
MyMembership.prototype.launch = function(onOffer) {
    // create an offer and get a string blob
    MyWebRTC.createOffer();
    MyWebRTC.on("allicecandidates+offer", onOffer);
}

###answer (handshaking step 2) Upon receiving an offer from {launch} through the signaling service the peer creates a fitting answer. This answer is propagated to the application with a callback that must be provided to this function. The answer must be send back to the communication initiator.

MyMembership.prototype.answer = function(offer, onOffer){
    MyWebRTC.createAnswer(offer);
    MyWebRTC.on("answercreated", onOffer);
}

###handshake (handshaking step 3) This is the final handshake-function that gets called after an answer is received

MyMembership.prototype.handshake = function(answer){
    MyWebRTC.acceptAnswer(answer);
}

###on Implement {event.EventEmitter}. We expect the following events:

{statechange}: applies when the state changes: @params = ["disconnect", "partial", "connect"]
{receive}: message is send. This is already filtered: @params = (sender {Peer}, message {Object||String}
{churn}: a received message, unfiltered by BroadcastDef: @params: (sender {Peer}, message {Object||String}

###ready This function checks if the membership protocol is already connected to the network and is "ready" or if the handshake is still pending. The parameter is a callback that gets called as soon as the peer is connected to the network. This function must apply the callback immediately, if it is ready!

MyMembership.prototype.ready = function(callback){
    if (MyWebRTC.handshakeIsDone()) {
        callback();
    } else {
        MyWebRTC.on("loaded", callback);
    }
}