@just-in/core
Version:
A TypeScript-first framework for building adaptive digital health interventions.
104 lines • 4.68 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.EventHandlerManager = void 0;
const logger_manager_1 = require("../logger/logger-manager");
class EventHandlerManager {
constructor() {
/**
* Registers a custom event by creating a standardized event object and adding it to the queue.
*
* @param {string} eventType - The type of event (e.g., 'CUSTOM_EVENT').
* @param {string[]} handlerNames - The list of handler names associated with the event.
* @returns {Promise<void>}
*/
this.registerEventHandlers = async (eventType, handlerNames, overwriteExisting = false) => {
this.validateEventHandlerParams(eventType, handlerNames);
if (this.hasHandlersForEventType(eventType) && !overwriteExisting) {
logger_manager_1.Log.error(`Event registration failed.Event "${eventType}" already registered.`);
throw new Error(`Event "${eventType}" already registered.`);
}
else {
this.handlerMap.set(eventType, handlerNames);
}
logger_manager_1.Log.info(`Event "${eventType}" registered with handlers: ${handlerNames} and added to the event registry.`);
};
/**
* Unregisters an event handler mapping by its event type.
*
* @param {string} eventType - The event type to unregister.
*/
this.unregisterEventHandlers = (eventType) => {
if (this.hasHandlersForEventType(eventType)) {
this.handlerMap.delete(eventType);
logger_manager_1.Log.info(`Event "${eventType}" unregistered.`);
}
else {
logger_manager_1.Log.warn(`Unregister event failed. Event "${eventType}" not found in the event registry.`);
}
};
/**
* Validates the parameters for an event registration.
*
* @param {string} eventType - The name of the event.
* @param {string[]} handlerNames - The list of handlers.
* @throws {Error} If the eventType or handlers are invalid.
*/
this.validateEventHandlerParams = (eventType, handlerNames) => {
if (!eventType || typeof eventType !== 'string') {
logger_manager_1.Log.error(`Invalid event type: "${eventType}"`);
throw new Error('Event name must be a non-empty string.');
}
if (!Array.isArray(handlerNames) ||
handlerNames.length === 0 ||
!handlerNames.every((h) => typeof h === 'string' && h !== '')) {
logger_manager_1.Log.error(`Invalid handler names for event "${eventType}": ${handlerNames}`);
throw new Error('Handler names must be a non-empty array of strings.');
}
};
/**
* Returns the handlers for a given event type.
*
* @param {string} eventType - The event type.
* @returns {string[]} The handler names for the event type.
*/
this.getHandlersForEventType = (eventType) => {
var _a;
if (!this.hasHandlersForEventType(eventType)) {
logger_manager_1.Log.error(`No handlers found for event type "${eventType}".`);
return [];
}
return (_a = this.handlerMap.get(eventType)) !== null && _a !== void 0 ? _a : [];
};
/**
* Checks if there are handlers for a given event type.
*
* @param {string} eventType - The event type.
* @returns {boolean} True if there are handlers for the event type, false otherwise.
*/
this.hasHandlersForEventType = (eventType) => {
return this.handlerMap.has(eventType);
};
/**
* Clears all event handlers from the event registry.
*/
this.clearEventHandlers = () => {
this.handlerMap.clear();
logger_manager_1.Log.info(`All event handlers cleared. handler map now: ${JSON.stringify(this.handlerMap)}.`);
};
this.handlerMap = new Map();
}
/**
* Returns the singleton instance of the EventManager.
*
* @returns {EventManager} The singleton instance of the EventManager.
*/
static getInstance() {
if (!EventHandlerManager.instance) {
EventHandlerManager.instance = new EventHandlerManager();
}
return EventHandlerManager.instance;
}
}
exports.EventHandlerManager = EventHandlerManager;
EventHandlerManager.instance = null;
//# sourceMappingURL=event-handler-manager.js.map