@pscoped/ngx-pub-sub/fesm2022/pscoped-ngx-pub-sub.mjs

Event publish - subscribe mechanism as Angular service using Observable. You can publish your event along with any data to all the subscribers of your event. This library also supports historical published values for the subscribers.

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

var SubjectType;
(function (SubjectType) {
    SubjectType[SubjectType["Subject"] = 0] = "Subject";
    SubjectType[SubjectType["BehaviorSubject"] = 1] = "BehaviorSubject";
    SubjectType[SubjectType["ReplaySubject"] = 2] = "ReplaySubject";
})(SubjectType || (SubjectType = {}));

class NgxPubSubService {
    constructor() {
        this.eventObservableMapping = {};
    }
    publishEvent(eventName, data) {
        this.validateEventName(eventName);
        this.createSubjectIfNotExist(eventName);
        this.publishNext(eventName, SubjectType.Subject, data);
    }
    subscribe(eventName, next, error, complete) {
        this.validateEventName(eventName);
        // subject will be created if the provided eventName is not registered
        this.createSubjectIfNotExist(eventName);
        return this.eventObservableMapping[eventName].ref.subscribe(next, error, complete);
    }
    /**
     * Use this method to get the Observable associated with the event.
     * Useful when you would like to apply additional rxjs operators like debounceTime
     */
    getEventObservable(eventName) {
        this.validateEventName(eventName);
        // subject will be created if the provided eventName is not registered
        this.createSubjectIfNotExist(eventName);
        return this.eventObservableMapping[eventName].ref.asObservable();
    }
    registerEventWithLastValue(name, defaultValue) {
        this.validateEventName(name);
        // type and name check
        this.checkEventType(name, SubjectType.BehaviorSubject, true);
        // create one
        this.eventObservableMapping[name] = {
            type: SubjectType.BehaviorSubject,
            ref: new BehaviorSubject(defaultValue)
        };
    }
    registerEventWithHistory(name, bufferSize, windowTime, scheduler) {
        this.validateEventName(name);
        // type and name check
        this.checkEventType(name, SubjectType.ReplaySubject, true);
        // create one
        this.eventObservableMapping[name] = {
            type: SubjectType.ReplaySubject,
            ref: new ReplaySubject(bufferSize, windowTime, scheduler)
        };
    }
    publishWithLast(eventName, data) {
        this.validateEventName(eventName);
        this.publishNext(eventName, SubjectType.BehaviorSubject, data);
    }
    publishWithHistory(eventName, data) {
        this.validateEventName(eventName);
        this.publishNext(eventName, SubjectType.ReplaySubject, data);
    }
    completeEvent(eventName) {
        this.validateEventName(eventName);
        if (!this.eventObservableMapping[eventName]) {
            throw Error('Event not created yet');
        }
        this.completeObservableAndDestroyMapping(eventName);
    }
    ngOnDestroy() {
        for (const eventName in this.eventObservableMapping) {
            // eslint-disable-next-line no-prototype-builtins
            if (this.eventObservableMapping.hasOwnProperty(eventName)) {
                this.completeObservableAndDestroyMapping(eventName);
            }
        }
    }
    publishNext(eventName, type = SubjectType.Subject, data) {
        this.checkEventType(eventName, type);
        this.eventObservableMapping[eventName].ref.next(data);
    }
    checkEventType(eventName, type = SubjectType.Subject, shouldNotExist = false) {
        const object = this.eventObservableMapping[eventName];
        let errorMessage;
        if (!object && shouldNotExist) {
            return;
        }
        if (!object) {
            errorMessage = `Event doesn't exist of type: ${SubjectType[type]} or it has been completed`;
        }
        else if (object.type !== type) {
            errorMessage = `Event exists with other type: ${SubjectType[object.type]}. Expected type: ${SubjectType[type]}`;
        }
        if (shouldNotExist && object.type === type) {
            errorMessage = `Event already registerd with the same type. Don't register a second time`;
        }
        if (errorMessage) {
            throw Error(`Error (${eventName}): ${errorMessage}`);
        }
    }
    createSubjectIfNotExist(eventName) {
        const object = this.eventObservableMapping[eventName];
        if (object) {
            return;
        }
        this.eventObservableMapping[eventName] = {
            type: SubjectType.Subject,
            ref: new Subject()
        };
    }
    validateEventName(eventName) {
        if (!eventName) {
            throw Error('Event name not provided');
        }
    }
    completeObservableAndDestroyMapping(eventName) {
        this.eventObservableMapping[eventName].ref.complete();
        delete this.eventObservableMapping[eventName];
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgxPubSubService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgxPubSubService }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgxPubSubService, decorators: [{
            type: Injectable
        }], ctorParameters: function () { return []; } });

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

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

export { NgxPubSubModule, NgxPubSubService };
//# sourceMappingURL=pscoped-ngx-pub-sub.mjs.map