@kephas/core
Version:
Provides a common infrastructure for all the other Kephas Framework components: ambient services, dynamic reflection, composition, application management, and others.
94 lines • 10.2 kB
JavaScript
// tslint:disable: max-classes-per-file
import { __decorate, __metadata } from "tslib";
import { Logger } from "../logging/logger";
import { AppService } from "../services/appService";
import { SingletonAppServiceContract } from "../services/appServiceContract";
import { Priority } from "../services/appServiceMetadata";
class EventSubscription {
constructor(match, callback, _onDispose) {
this.match = match;
this.callback = callback;
this._onDispose = _onDispose;
}
dispose() {
this._onDispose(this);
}
}
/**
* Singleton application service handling in-process event publishing/subscribing.
*
* @export
* @class EventHub
*/
let EventHub = class EventHub {
/**
* Creates an instance of EventHub.
*
* @param {Logger} logger The logger.
* @memberof EventHub
*/
constructor(logger) {
this._subscriptions = [];
this._logger = logger || new Logger();
}
/**
* Gets the logger.
*
* @readonly
* @protected
* @type {Logger}
* @memberof EventHub
*/
get logger() {
return this._logger;
}
/**
* Publishes the event asynchronously to its subscribers.
*
* @param {*} event The event.
* @param {Context} [context] Optional. The context.
* @returns {Promise<any>} The promise.
* @memberof EventHub
*/
async publishAsync(event, context) {
const subscriptions = this._subscriptions.filter(s => s.match(event));
for (const subscription of subscriptions) {
try {
const promise = subscription.callback(event, context);
if (promise) {
await promise;
}
}
catch (err) {
this.logger.error(err);
}
}
}
/**
* Subscribes to the event(s) matching the criteria.
*
* @template T The event type.
* @param {(AbstractType | Type<T>)} match Specifies the match type.
* @param {((event: T, context?: Context) => Promise<any> | void)} callback The callback.
* @returns {Disposable} A disposable event subscription.
* @memberof EventHub
*/
subscribe(match, callback) {
const subscription = new EventSubscription(this._getMatch(match), callback, s => {
const i = this._subscriptions.indexOf(s);
this._subscriptions.splice(i, 1);
});
this._subscriptions.push(subscription);
return subscription;
}
_getMatch(match) {
return event => event instanceof match;
}
};
EventHub = __decorate([
AppService({ overridePriority: Priority.Low }),
SingletonAppServiceContract(),
__metadata("design:paramtypes", [Logger])
], EventHub);
export { EventHub };
//# sourceMappingURL=data:application/json;base64,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