@spartacus/core
Version:
Spartacus - the core framework
164 lines • 20.3 kB
JavaScript
import { Injectable, isDevMode } from '@angular/core';
import { Subject } from 'rxjs';
import { tap } from 'rxjs/operators';
import { createFrom } from '../util/create-from';
import { CxEvent } from './cx-event';
import { MergingSubject } from './utils/merging-subject';
import * as i0 from "@angular/core";
/**
* A service to register and observe event sources. Events are driven by event types, which are class signatures
* for the given event.
*
* It is possible to register multiple sources to a single event, even without
* knowing as multiple decoupled features can attach sources to the same
* event type.
*/
export class EventService {
constructor() {
/**
* The various events meta are collected in a map, stored by the event type class
*/
this.eventsMeta = new Map();
}
/**
* Register an event source for the given event type.
*
* CAUTION: To avoid memory leaks, the returned teardown function should be called
* when the event source is no longer maintained by its creator
* (i.e. in `ngOnDestroy` if the event source was registered in the component).
*
* @since 3.1 - registers the given `source$` for the parent classes of the given `eventType`.
*
* @param eventType the event type
* @param source$ an observable that represents the source
*
* @returns a teardown function which unregisters the given event source
*/
register(eventType, source$) {
const eventMeta = this.getEventMeta(eventType);
if (eventMeta.mergingSubject.has(source$)) {
if (isDevMode()) {
console.warn(`EventService: the event source`, source$, `has been already registered for the type`, eventType);
}
}
else {
eventMeta.mergingSubject.add(source$);
}
return () => eventMeta.mergingSubject.remove(source$);
}
/**
* Returns a stream of events for the given event type
* @param eventTypes event type
*/
get(eventType) {
let output$ = this.getEventMeta(eventType).mergingSubject.output$;
if (isDevMode()) {
output$ = this.getValidatedEventStream(output$, eventType);
}
return output$;
}
/**
* Dispatches an instance of an individual event.
* If the eventType is provided a new event will be created for that type and with the event data.
*
* @param event an event
* @param eventType (optional) - type of event
*/
dispatch(event, eventType) {
if (!eventType) {
eventType = event.constructor;
}
else if (!(event instanceof eventType)) {
event = createFrom(eventType, event);
}
const inputSubject$ = this.getInputSubject(eventType);
inputSubject$.next(event);
}
/**
* Returns the input subject used to dispatch a single event.
* The subject is created on demand, when it's needed for the first time.
* @param eventType type of event
*/
getInputSubject(eventType) {
const eventMeta = this.getEventMeta(eventType);
if (!eventMeta.inputSubject$) {
eventMeta.inputSubject$ = new Subject();
this.register(eventType, eventMeta.inputSubject$);
}
return eventMeta.inputSubject$;
}
/**
* Returns the event meta object for the given event type
*/
getEventMeta(eventType) {
if (!this.eventsMeta.get(eventType)) {
if (isDevMode()) {
this.validateEventType(eventType);
}
this.createEventMeta(eventType);
}
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
return this.eventsMeta.get(eventType);
}
createEventMeta(eventType) {
const eventMeta = {
inputSubject$: null,
mergingSubject: new MergingSubject(),
};
this.eventsMeta.set(eventType, eventMeta);
let parentEvent = Object.getPrototypeOf(eventType);
while (parentEvent !== null &&
Object.getPrototypeOf(parentEvent) !== Object.getPrototypeOf({})) {
this.register(parentEvent, eventMeta.mergingSubject.output$);
parentEvent = Object.getPrototypeOf(parentEvent);
}
}
/**
* Checks if the event type is a valid type (is a class with constructor).
*
* Should be used only in dev mode.
*/
validateEventType(eventType) {
if (!(eventType === null || eventType === void 0 ? void 0 : eventType.constructor)) {
throw new Error(`EventService: ${eventType} is not a valid event type. Please provide a class reference.`);
}
this.validateCxEvent(eventType);
}
/**
* Validates if the given type (or its prototype chain) extends from the CxEvent.
*
* Should be used only in the dev mode.
*/
validateCxEvent(eventType) {
let parentType = eventType;
while (parentType !== null &&
Object.getPrototypeOf(parentType) !== Object.getPrototypeOf({})) {
if (parentType.type === CxEvent.type) {
return;
}
parentType = Object.getPrototypeOf(parentType);
}
console.warn(`The ${eventType.name} (or one of its parent classes) does not inherit from the ${CxEvent.type}`);
}
/**
* Returns the given event source with runtime validation whether the emitted values are instances of given event type.
*
* Should be used only in dev mode.
*/
getValidatedEventStream(source$, eventType) {
return source$.pipe(tap((event) => {
if (!(event instanceof eventType)) {
console.warn(`EventService: The stream`, source$, `emitted the event`, event, `that is not an instance of the declared type`, eventType.name);
}
}));
}
}
EventService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: EventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
EventService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: EventService, providedIn: 'root' });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: EventService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root',
}]
}] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event.service.js","sourceRoot":"","sources":["../../../../../projects/core/src/event/event.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractType, Injectable, isDevMode, Type } from '@angular/core';\nimport { Observable, Subject } from 'rxjs';\nimport { tap } from 'rxjs/operators';\nimport { createFrom } from '../util/create-from';\nimport { CxEvent } from './cx-event';\nimport { MergingSubject } from './utils/merging-subject';\n\n/**\n * The object holds registered source observables as well as the merged result observable.\n */\ninterface EventMeta<T> {\n  /**\n   * Input subject used for dispatching occasional event (without registering a source)\n   */\n  inputSubject$: Subject<T> | null;\n\n  /**\n   * A custom subject that allows for dynamic adding and removing sources to be merged as an output\n   */\n  mergingSubject: MergingSubject<T>;\n}\n\n/**\n * A service to register and observe event sources. Events are driven by event types, which are class signatures\n * for the given event.\n *\n * It is possible to register multiple sources to a single event, even without\n * knowing as multiple decoupled features can attach sources to the same\n * event type.\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class EventService {\n  /**\n   * The various events meta are collected in a map, stored by the event type class\n   */\n  private eventsMeta = new Map<AbstractType<any> | any, EventMeta<any>>();\n\n  /**\n   * Register an event source for the given event type.\n   *\n   * CAUTION: To avoid memory leaks, the returned teardown function should be called\n   *  when the event source is no longer maintained by its creator\n   * (i.e. in `ngOnDestroy` if the event source was registered in the component).\n   *\n   * @since 3.1 - registers the given `source$` for the parent classes of the given `eventType`.\n   *\n   * @param eventType the event type\n   * @param source$ an observable that represents the source\n   *\n   * @returns a teardown function which unregisters the given event source\n   */\n  register<T>(eventType: AbstractType<T>, source$: Observable<T>): () => void {\n    const eventMeta = this.getEventMeta(eventType);\n    if (eventMeta.mergingSubject.has(source$)) {\n      if (isDevMode()) {\n        console.warn(\n          `EventService: the event source`,\n          source$,\n          `has been already registered for the type`,\n          eventType\n        );\n      }\n    } else {\n      eventMeta.mergingSubject.add(source$);\n    }\n\n    return () => eventMeta.mergingSubject.remove(source$);\n  }\n\n  /**\n   * Returns a stream of events for the given event type\n   * @param eventTypes event type\n   */\n  get<T>(eventType: AbstractType<T>): Observable<T> {\n    let output$ = this.getEventMeta(eventType).mergingSubject.output$;\n    if (isDevMode()) {\n      output$ = this.getValidatedEventStream(output$, eventType);\n    }\n    return output$;\n  }\n\n  /**\n   * Dispatches an instance of an individual event.\n   * If the eventType is provided a new event will be created for that type and with the event data.\n   *\n   * @param event an event\n   * @param eventType (optional) - type of event\n   */\n  dispatch<T extends object>(event: T, eventType?: Type<T>): void {\n    if (!eventType) {\n      eventType = event.constructor as Type<T>;\n    } else if (!(event instanceof eventType)) {\n      event = createFrom(eventType, event);\n    }\n    const inputSubject$ = this.getInputSubject(eventType);\n    inputSubject$.next(event);\n  }\n\n  /**\n   * Returns the input subject used to dispatch a single event.\n   * The subject is created on demand, when it's needed for the first time.\n   * @param eventType type of event\n   */\n  private getInputSubject<T>(eventType: AbstractType<T>): Subject<T> {\n    const eventMeta = this.getEventMeta(eventType);\n\n    if (!eventMeta.inputSubject$) {\n      eventMeta.inputSubject$ = new Subject<any>();\n      this.register(eventType, eventMeta.inputSubject$);\n    }\n    return eventMeta.inputSubject$;\n  }\n\n  /**\n   * Returns the event meta object for the given event type\n   */\n  private getEventMeta<T>(eventType: AbstractType<T>): EventMeta<T> {\n    if (!this.eventsMeta.get(eventType)) {\n      if (isDevMode()) {\n        this.validateEventType(eventType);\n      }\n      this.createEventMeta(eventType);\n    }\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    return this.eventsMeta.get(eventType)!;\n  }\n\n  private createEventMeta<T>(eventType: AbstractType<T>): void {\n    const eventMeta: EventMeta<T> = {\n      inputSubject$: null, // will be created lazily by the `dispatch` method\n      mergingSubject: new MergingSubject<T>(),\n    };\n    this.eventsMeta.set(eventType, eventMeta);\n\n    let parentEvent = Object.getPrototypeOf(eventType);\n    while (\n      parentEvent !== null &&\n      Object.getPrototypeOf(parentEvent) !== Object.getPrototypeOf({})\n    ) {\n      this.register(parentEvent, eventMeta.mergingSubject.output$);\n      parentEvent = Object.getPrototypeOf(parentEvent);\n    }\n  }\n\n  /**\n   * Checks if the event type is a valid type (is a class with constructor).\n   *\n   * Should be used only in dev mode.\n   */\n  private validateEventType<T>(eventType: AbstractType<T>): void {\n    if (!eventType?.constructor) {\n      throw new Error(\n        `EventService:  ${eventType} is not a valid event type. Please provide a class reference.`\n      );\n    }\n\n    this.validateCxEvent(eventType);\n  }\n\n  /**\n   * Validates if the given type (or its prototype chain) extends from the CxEvent.\n   *\n   * Should be used only in the dev mode.\n   */\n  private validateCxEvent<T>(eventType: AbstractType<T>): void {\n    let parentType = eventType;\n    while (\n      parentType !== null &&\n      Object.getPrototypeOf(parentType) !== Object.getPrototypeOf({})\n    ) {\n      if ((parentType as any).type === CxEvent.type) {\n        return;\n      }\n\n      parentType = Object.getPrototypeOf(parentType);\n    }\n\n    console.warn(\n      `The ${eventType.name} (or one of its parent classes) does not inherit from the ${CxEvent.type}`\n    );\n  }\n\n  /**\n   * Returns the given event source with runtime validation whether the emitted values are instances of given event type.\n   *\n   * Should be used only in dev mode.\n   */\n  private getValidatedEventStream<T>(\n    source$: Observable<T>,\n    eventType: AbstractType<T>\n  ): Observable<T> {\n    return source$.pipe(\n      tap((event) => {\n        if (!(event instanceof eventType)) {\n          console.warn(\n            `EventService: The stream`,\n            source$,\n            `emitted the event`,\n            event,\n            `that is not an instance of the declared type`,\n            eventType.name\n          );\n        }\n      })\n    );\n  }\n}\n"]}