ngx-message-bus/fesm2015/ngx-message-bus.js

Messaging system for angular 11.x application. It allows communication between components and modules. Direct messages, messages by types and broadcasting.

import { ɵɵdefineInjectable, Injectable } from '@angular/core';

class Connection {
    constructor(hub, subscriberId) {
        this.hub = hub;
        this.subscriberId = subscriberId;
    }
    getHubName() {
        return this.hub.getHubName();
    }
    getSubscriberId() {
        return this.subscriberId.toString();
    }
    off(subscription) {
        this.hub.removeListener(this.subscriptionToListener(subscription));
    }
    offBroadcast() {
        this.hub.removeBroadcastListener(this.getSubscriberId());
    }
    on(subscription) {
        this.hub.addListener(this.subscriptionToListener(subscription));
    }
    onBroadcast(callBack) {
        this.hub.addBroadcastListener({
            subscriberId: this.subscriberId,
            callback: callBack,
            groupId: null
        });
    }
    post(message) {
        message.publisherId = this.subscriberId;
        message.timeGenerated = new Date();
        this.hub.post(message);
    }
    broadcast(data) {
        const message = {
            publisherId: this.subscriberId,
            payload: data,
            timeGenerated: new Date(),
            groupId: null,
            metadata: null,
            recipientIds: null
        };
        this.hub.broadcast(message);
    }
    subscriptionToListener(subscription) {
        return {
            subscriberId: this.getSubscriberId(),
            groupId: subscription.groupId,
            callback: subscription.callback
        };
    }
}

var ErrorHandlingEnum;
(function (ErrorHandlingEnum) {
    ErrorHandlingEnum[ErrorHandlingEnum["None"] = 0] = "None";
    ErrorHandlingEnum[ErrorHandlingEnum["Throw"] = 1] = "Throw";
    ErrorHandlingEnum[ErrorHandlingEnum["Log"] = 3] = "Log";
})(ErrorHandlingEnum || (ErrorHandlingEnum = {}));

class Hub {
    constructor(hubName, errorHanndling) {
        this.errorHanndling = errorHanndling;
        this.subscribers = [];
        this.listeners = [];
        this.broadcastListeners = [];
        this.hubName = hubName;
    }
    connect(connection) {
        this.subscribers.push(connection);
    }
    disconnect(connection) {
        if (!this.subscribers || this.subscribers.length === 0) {
            return;
        }
        const subscriberIndex = this.subscribers.findIndex(sub => sub.getSubscriberId() === connection.getSubscriberId());
        if (subscriberIndex >= 0) {
            this.subscribers.splice(subscriberIndex, 1);
        }
        if (this.isAnyListener()) {
            let listenerIndex = -1;
            while ((listenerIndex = this.listeners.findIndex(l => l.subscriberId.toString() === connection.getSubscriberId())) >= 0) {
                this.listeners.splice(listenerIndex, 1);
            }
        }
        if (this.isAnyBroadcastListener()) {
            let broadcastListenerIndex = -1;
            while ((broadcastListenerIndex = this.broadcastListeners
                .findIndex(l => l.subscriberId.toString() === connection.getSubscriberId())) >= 0) {
                this.broadcastListeners.splice(broadcastListenerIndex, 1);
            }
        }
    }
    getActiveConnections() {
        return this.subscribers.length;
    }
    addListener(listener) {
        if (!this.listeners.find(l => l.subscriberId.toString() === listener.subscriberId.toString()
            && l.groupId.toString() === listener.groupId.toString())) {
            this.listeners.push(listener);
        }
    }
    addBroadcastListener(listener) {
        if (!this.broadcastListeners.find(l => l.subscriberId.toString() === listener.subscriberId.toString())) {
            this.broadcastListeners.push(listener);
        }
    }
    removeListener(listener) {
        if (!this.isAnyListener()) {
            return;
        }
        const listenerToRemoveIndex = this.listeners
            .findIndex(l => l.subscriberId.toString() === listener.subscriberId.toString()
            && l.groupId.toString() === listener.groupId.toString());
        if (listenerToRemoveIndex > -1) {
            this.listeners.splice(listenerToRemoveIndex, 1);
        }
    }
    removeBroadcastListener(subscriberId) {
        if (!this.isAnyBroadcastListener()) {
            return;
        }
        const listenerToRemoveIndex = this.broadcastListeners
            .findIndex(listener => listener.subscriberId.toString() === subscriberId.toString());
        if (listenerToRemoveIndex > -1) {
            this.broadcastListeners.splice(listenerToRemoveIndex, 1);
        }
    }
    getHubName() {
        return this.hubName;
    }
    post(message) {
        if (!this.isAnyListener() && message) {
            return;
        }
        let recipients = this.listeners;
        if (!message.recipientIds || message.recipientIds.indexOf(message.publisherId.toString()) < 0) {
            recipients = recipients.filter(l => l.subscriberId.toString() !== message.publisherId.toString());
        }
        if (message.recipientIds && message.recipientIds.length > 0) {
            recipients = recipients.filter(sub => message.recipientIds.indexOf(sub.subscriberId.toString()) >= 0);
        }
        if (message.groupId && message.groupId.length > 0) {
            recipients = recipients.filter(sub => sub.groupId.toString() === message.groupId.toString());
        }
        if (!recipients || recipients.length === 0) {
            return;
        }
        recipients.forEach(recipient => {
            try {
                recipient.callback(message.payload);
            }
            catch (e) {
                switch (this.errorHanndling) {
                    case ErrorHandlingEnum.Log:
                        console.error(e);
                        break;
                    case ErrorHandlingEnum.Throw:
                        throw e;
                    case ErrorHandlingEnum.None:
                    default:
                        break;
                }
            }
        });
    }
    broadcast(message) {
        if (!this.isAnyBroadcastListener()) {
            return;
        }
        this.broadcastListeners
            .filter(listener => listener.subscriberId.toString() !== message.publisherId.toString())
            .forEach(listener => listener.callback(message.payload));
    }
    dispose() {
        this.subscribers = null;
        this.broadcastListeners = null;
        this.hubName = null;
        this.listeners = null;
    }
    isAnyListener() {
        return this.listeners && this.listeners.length > 0;
    }
    isAnyBroadcastListener() {
        return this.broadcastListeners && this.broadcastListeners.length > 0;
    }
}

class Listener {
}

class Message {
}

class Subscription {
}

class MessageBus {
    constructor() {
        this.errorHandling = ErrorHandlingEnum.Log;
        this.hubs = {};
    }
    setLogLevel(errorHandling) {
        this.errorHandling = errorHandling;
    }
    connect(hubName, subscriberId) {
        hubName = hubName.toString();
        if (!this.hubs[hubName] || this.hubs[hubName] === null) {
            this.hubs[hubName] = new Hub(hubName, this.errorHandling);
        }
        const hub = this.hubs[hubName];
        const connection = new Connection(hub, subscriberId);
        hub.connect(connection);
        return connection;
    }
    disconnect(connection) {
        if (!connection || connection == null) {
            return;
        }
        const hubName = connection.getHubName().toString();
        let hub = this.hubs[hubName];
        if (hub) {
            hub.disconnect(connection);
            if (hub.getActiveConnections() < 1) {
                hub.dispose();
                this.hubs[hubName] = null;
            }
        }
    }
}
MessageBus.ɵprov = ɵɵdefineInjectable({ factory: function MessageBus_Factory() { return new MessageBus(); }, token: MessageBus, providedIn: "root" });
MessageBus.decorators = [
    { type: Injectable, args: [{
                providedIn: 'root'
            },] }
];
MessageBus.ctorParameters = () => [];

/**
 * Generated bundle index. Do not edit.
 */

export { Connection, ErrorHandlingEnum, Hub, Listener, Message, MessageBus, Subscription };
//# sourceMappingURL=ngx-message-bus.js.map