ngrx-event-bus/fesm2020/ngrx-event-bus.mjs

Angular and RxJs event bus with Mediator Pattern

import * as i0 from '@angular/core';
import { Injectable, NgModule } from '@angular/core';
import { BehaviorSubject, Subject } from 'rxjs';
import { CommonModule } from '@angular/common';

class EmitEvent {
    constructor(name, value) {
        this.name = name;
        this.value = value;
    }
}
var EmitRecord;
(function (EmitRecord) {
    EmitRecord[EmitRecord["First"] = 1] = "First";
    EmitRecord[EmitRecord["Last"] = 2] = "Last";
    EmitRecord[EmitRecord["All"] = 3] = "All";
})(EmitRecord || (EmitRecord = {}));

class NgRxEventBusService {
    constructor() {
        this.eventLastEmitted = {};
        this.eventRegister = new Map();
    }
    //#region Public
    /**
      * register event with or without default value.
      * @param event should be IEvent type.
      * @param defaultValue is option if data passed BehaviorSubject type has been considered else Subject type.
      */
    registerEvent(event, defaultValue) {
        let eventRegister = this.eventRegister.get(event);
        if (eventRegister && eventRegister.unRegister === false) {
            throw `${event} event already registered`;
        }
        else if (eventRegister && eventRegister.unRegister) {
            eventRegister.unRegister = false;
            return;
        }
        eventRegister = {
            event: event,
            subject: defaultValue ? new BehaviorSubject(defaultValue) : new Subject()
        };
        this.eventRegister.set(event, eventRegister);
    }
    /**
      * unregister the event.
      * @param event should be IEvent type.
    */
    unregisterEvent(event, soft = false) {
        const eventRegister = this.eventRegister.get(event);
        if (eventRegister) {
            if (soft) {
                eventRegister.unRegister = true;
            }
            else {
                eventRegister.subject.unsubscribe();
                this.eventRegister.delete(event);
            }
            return true;
        }
        return false;
    }
    /**
       * Binding function to subscribe the published event.
       * If event has not registered, it will register the same with default Subject type
       * @param event should be IEvent type.
       * @param action callback function when something event got publish.
       * @param emittedValue by the event based on selected enum.
    */
    on(event, action, emittedValue) {
        let eventRegister = this.eventRegister.get(event);
        if (!eventRegister) {
            eventRegister = { event: event, subject: new Subject() };
            this.eventRegister.set(event, eventRegister);
        }
        if (this.eventLastEmitted[event] && emittedValue) {
            let response;
            const eventName = event;
            switch (emittedValue) {
                case EmitRecord.First:
                    response = this.eventLastEmitted[eventName][0];
                    break;
                case EmitRecord.Last:
                    response = this.eventLastEmitted[eventName][this.eventLastEmitted[eventName].length - 1];
                    break;
                case EmitRecord.All:
                    response = this.eventLastEmitted[eventName];
                    break;
            }
            setTimeout((data) => {
                eventRegister.subject.next(data);
            }, 0, response);
        }
        return eventRegister.subject.subscribe(action);
    }
    /**
       * Publish event using this function.
       * If event has not registered it will register it with default BehaviorSubject type
       * @param event should be EmitEvent type.
    */
    emit(event) {
        let eventRegister = this.eventRegister.get(event.name);
        if (!eventRegister) {
            eventRegister = { event: event.name, subject: new BehaviorSubject(event.value) };
            this.eventRegister.set(event.name, eventRegister);
        }
        else if (eventRegister.unRegister) {
            return;
        }
        eventRegister.subject.next(event.value);
        this.eventLastEmitted[event.name] = this.eventLastEmitted[event.name] || [];
        this.eventLastEmitted[event.name].push(event.value);
    }
}
NgRxEventBusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NgRxEventBusService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
NgRxEventBusService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NgRxEventBusService, providedIn: 'root' });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NgRxEventBusService, decorators: [{
            type: Injectable,
            args: [{
                    providedIn: 'root'
                }]
        }], ctorParameters: function () { return []; } });

class NgRxEventBusModule {
}
NgRxEventBusModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NgRxEventBusModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
NgRxEventBusModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NgRxEventBusModule, imports: [CommonModule] });
NgRxEventBusModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NgRxEventBusModule, providers: [NgRxEventBusService], imports: [[CommonModule]] });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NgRxEventBusModule, decorators: [{
            type: NgModule,
            args: [{
                    imports: [CommonModule],
                    providers: [NgRxEventBusService]
                }]
        }] });

/*
 * Public API Surface of ngrx-event-bus
 */

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

export { EmitEvent, EmitRecord, NgRxEventBusModule, NgRxEventBusService };
//# sourceMappingURL=ngrx-event-bus.mjs.map