app-bus/dist/app-bus.js

An asynchronous application event bus for javascript designed to work with the pub/sub paradigm.

'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

function AppBus() {

    var postedPublications = [];
    var queuedPublications = [];
    var subscriptions = [];

    var curryDeliveryJob = function curryDeliveryJob(subscriber) {
        return function (payload) {
            subscriber.apply(null, [payload]);
        };
    };

    var makeSubscription = function makeSubscription(subscriber, eventName) {
        var send = curryDeliveryJob(subscriber);
        return {
            subscriber: subscriber,
            eventName: eventName,
            send: send
        };
    };

    var findSubscriptions = function findSubscriptions(eventName, subscriber) {
        var foundSubscriptions = [];
        subscriptions.forEach(function (subscription) {
            if (subscription.eventName === eventName) {
                if (subscriber) {
                    if (subscription.subscriber === subscriber) {
                        foundSubscriptions.push(subscription);
                    }
                } else {
                    foundSubscriptions.push(subscription);
                }
            }
        });
        return foundSubscriptions;
    };

    var publishToSubscribers = function publishToSubscribers(eventName, payload) {
        var foundSubscriptions = findSubscriptions(eventName);
        foundSubscriptions.forEach(function (subscription) {
            subscription.send(payload);
        });
    };

    var processQueuedPublications = function processQueuedPublications(eventName) {
        for (var i = 0; i < queuedPublications.length; i++) {
            var queuedPublication = queuedPublications[i];
            if (queuedPublication.eventName === eventName) {
                publishToSubscribers(queuedPublication.eventName, queuedPublication.payload);
                queuedPublications.splice(i, 1);
                i -= 1;
            }
        }
    };

    var processPostedPublications = function processPostedPublications(eventName) {
        for (var i = 0; i < postedPublications.length; i++) {
            var postedPublication = postedPublications[i];
            if (postedPublication.eventName === eventName) {
                publishToSubscribers(postedPublication.eventName, postedPublication.payload);
            }
        }
    };

    var validateEventName = function validateEventName(eventName) {
        if (typeof eventName !== 'string') {
            throw new Error('The eventName argument is not a string. Found: ' + (typeof eventName === 'undefined' ? 'undefined' : _typeof(eventName)));
        }
    };

    var validateSubscriber = function validateSubscriber(subscriber) {
        if (typeof subscriber !== 'function') {
            throw new Error('The subscriber argument is not a Function. Found: ' + (typeof subscriber === 'undefined' ? 'undefined' : _typeof(subscriber)));
        }
    };

    var addSubscription = function addSubscription(subscriber, eventName) {
        var duplicateSubscriptions = findSubscriptions(eventName, subscriber);
        if (duplicateSubscriptions.length > 0) {
            return;
        }
        var subscription = makeSubscription(subscriber, eventName);
        subscriptions.push(subscription);
        processPostedPublications(eventName);
        processQueuedPublications(eventName);
    };

    var removeSubscription = function removeSubscription(subscriber, eventName) {
        for (var i = 0; i < subscriptions.length; i++) {
            var subscription = subscriptions[i];
            if (subscription.eventName === eventName && subscription.subscriber === subscriber) {
                subscriptions.splice(i, 1);
                i -= 1;
            }
        }
    };

    var postPublication = function postPublication(eventName, payload) {
        var publication = {
            eventName: eventName,
            payload: payload
        };
        var foundSubscriptions = findSubscriptions(eventName);
        if (foundSubscriptions.length) {
            publishToSubscribers(eventName, payload);
        }
        for (var i = 0; i < postedPublications.length; i++) {
            var postedPublication = postedPublications[i];
            if (postedPublication.eventName === eventName) {
                postedPublications.splice(i, 1);
                i -= 1;
            }
        }
        postedPublications.push(publication);
    };

    var queuePublication = function queuePublication(eventName, payload) {
        var publication = {
            eventName: eventName,
            payload: payload
        };
        var foundSubscriptions = findSubscriptions(eventName);
        if (foundSubscriptions.length) {
            publishToSubscribers(eventName, payload);
        } else {
            queuedPublications.push(publication);
        }
    };

    var queueOnlyLatestPublication = function queueOnlyLatestPublication(eventName, payload) {
        for (var i = 0; i < queuedPublications.length; i++) {
            var queuedPublication = queuedPublications[i];
            if (queuedPublication.eventName === eventName) {
                queuedPublications.splice(i, 1);
                i -= 1;
            }
        }
        queuePublication(eventName, payload);
    };

    var clearAllSubscriptions = function clearAllSubscriptions() {
        subscriptions.splice(0, subscriptions.length);
    };

    var clearAllQueuedPublications = function clearAllQueuedPublications() {
        queuedPublications.splice(0, queuedPublications.length);
    };

    var clearAllPostedPublications = function clearAllPostedPublications() {
        postedPublications.splice(0, postedPublications.length);
    };

    var clearSubscriptionsByEventName = function clearSubscriptionsByEventName(eventName) {
        for (var i = 0; i < subscriptions.length; i++) {
            var subscription = subscriptions[i];
            if (subscription.eventName === eventName) {
                subscriptions.splice(i, 1);
                i -= 1;
            }
        }
    };

    var clearQueuedPublicationsByEventName = function clearQueuedPublicationsByEventName(eventName) {
        for (var i = 0; i < queuedPublications.length; i++) {
            var queuedPublication = queuedPublications[i];
            if (queuedPublication.eventName === eventName) {
                queuedPublications.splice(i, 1);
                i -= 1;
            }
        }
    };

    var clearPostedPublicationsByEventName = function clearPostedPublicationsByEventName(eventName) {
        for (var i = 0; i < postedPublications.length; i++) {
            var postedPublication = postedPublications[i];
            if (postedPublication.eventName === eventName) {
                postedPublications.splice(i, 1);
                i -= 1;
            }
        }
    };

    var curryTo = function curryTo(subscriber) {
        return {
            to: function to(eventName) {
                addSubscription(subscriber, eventName);
            }
        };
    };

    var curryFrom = function curryFrom(subscriber) {
        return {
            from: function from(eventName) {
                removeSubscription(subscriber, eventName);
            }
        };
    };

    var curryQueueOptions = function curryQueueOptions(eventName, payload) {
        return {
            all: function all() {
                queuePublication(eventName, payload);
            },
            latest: function latest() {
                queueOnlyLatestPublication(eventName, payload);
            }
        };
    };

    var curryTimingOptions = function curryTimingOptions(eventName, payload) {
        return {
            now: function now() {
                publishToSubscribers(eventName, payload);
            },
            post: function post() {
                postPublication(eventName, payload);
            },
            queue: curryQueueOptions(eventName, payload)
        };
    };

    var curryPublishOptions = function curryPublishOptions(eventName) {
        return {
            now: function now() {
                publishToSubscribers(eventName);
            },
            queue: curryQueueOptions(eventName),
            post: function post() {
                postPublication(eventName);
            },
            with: function _with(payload) {
                return curryTimingOptions(eventName, payload);
            }
        };
    };

    var clearOptions = {
        posts: {
            all: clearAllPostedPublications,
            byEventName: clearPostedPublicationsByEventName
        },
        queue: {
            all: clearAllQueuedPublications,
            byEventName: clearQueuedPublicationsByEventName
        },
        subscriptions: {
            all: clearAllSubscriptions,
            byEventName: clearSubscriptionsByEventName
        }
    };

    var subscribe = function subscribe(subscriber) {
        validateSubscriber(subscriber);
        return curryTo(subscriber);
    };

    var unSubscribe = function unSubscribe(subscriber) {
        validateSubscriber(subscriber);
        return curryFrom(subscriber);
    };

    var publish = function publish(eventName) {
        validateEventName(eventName);
        return curryPublishOptions(eventName);
    };

    return {
        subscribe: subscribe,
        publish: publish,
        unSubscribe: unSubscribe,
        clear: clearOptions
    };
}

var AppBusFactory = {
    new: function _new() {
        return AppBus();
    }
};

module.exports = AppBusFactory;
//# sourceMappingURL=app-bus.js.map