djsbotbase-test
Version:
Discord.js tabanlı komut ve etkinlik sistemlerine sahip bir bot temeli
178 lines (177 loc) • 6.98 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.EventHandler = void 0;
const eventClass_1 = require("./eventClass");
const promises_1 = require("fs/promises");
const logger_1 = require("../helpers/logger");
class EventHandler {
constructor(data) {
Object.defineProperty(this, "eventMap", {
enumerable: true,
configurable: true,
writable: true,
value: new Map()
});
Object.defineProperty(this, "eventsDir", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "suppressWarnings", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
this.eventsDir = this.validateAndGetEventsDir(data?.eventsDir);
this.suppressWarnings = this.validateAndGetSuppressWarnings(data?.suppressWarnings);
}
validateAndGetEventsDir(eventsDir) {
if (eventsDir !== undefined && typeof eventsDir !== "string") {
(0, logger_1.error)("eventsDir must be a string.");
}
return eventsDir ?? "events";
}
validateAndGetSuppressWarnings(suppressWarnings) {
if (suppressWarnings !== undefined && typeof suppressWarnings !== "boolean") {
(0, logger_1.error)("suppressWarnings must be a boolean.");
}
return suppressWarnings ?? false;
}
async setEvents(client) {
this.clearEventsIfExist(client);
await this.loadAndRegisterEvents(client);
}
clearEventsIfExist(client) {
if (this.eventMap.size > 0) {
this.clearEvents(client);
(0, logger_1.logInfo)("Old events cleared before setting new events.");
}
}
async loadAndRegisterEvents(client) {
try {
const eventFiles = await this.readEventFiles();
const eventCategoryMap = await this.processEventFiles(eventFiles);
this.registerEventCategories(client, eventCategoryMap);
this.logRegistrationSummary();
}
catch (error) {
(0, logger_1.logError)("Reading events failed!");
console.error(error);
}
}
async readEventFiles() {
const normalizedEventsDir = this.eventsDir.startsWith("./")
? this.eventsDir
: `./${this.eventsDir}`;
const dirents = await (0, promises_1.readdir)(normalizedEventsDir, { withFileTypes: true });
(0, logger_1.logInfo)("Reading events...");
return dirents
.filter(dirent => dirent.isFile())
.map(dirent => dirent.name)
.filter(name => this.isValidEventFile(name));
}
isValidEventFile(fileName) {
const fileRegex = /^[\w\s]+\.(js|ts)$/;
if (!fileRegex.test(fileName)) {
if (!this.suppressWarnings) {
(0, logger_1.logWarn)(`'${fileName}' is not a valid JavaScript/TypeScript file.`);
}
return false;
}
return true;
}
async processEventFiles(eventFiles) {
const eventCategoryMap = new Map();
for (const fileName of eventFiles) {
try {
const event = await this.loadEventFromFile(fileName);
if (event) {
this.addEventToCategory(eventCategoryMap, event);
(0, logger_1.logInfo)(`Event file '${fileName}' loaded.`);
}
}
catch (error) {
(0, logger_1.logError)(`Loading event '${fileName}' failed!`);
console.error(error);
}
}
return eventCategoryMap;
}
async loadEventFromFile(fileName) {
const normalizedEventsDir = this.eventsDir.startsWith("./")
? this.eventsDir
: `./${this.eventsDir}`;
const eventPath = `../../../../${normalizedEventsDir}/${fileName}`;
const eventModule = await import(eventPath);
const eventData = eventModule?.default;
if (!eventData) {
if (!this.suppressWarnings) {
(0, logger_1.logWarn)(`'${fileName}' does not have a default export.`);
}
return null;
}
if (!(eventData instanceof eventClass_1.Event)) {
if (!this.suppressWarnings) {
(0, logger_1.logWarn)(`'${fileName}' does not export an Event instance as default.`);
}
return null;
}
return eventData;
}
addEventToCategory(eventCategoryMap, event) {
const existingEvents = eventCategoryMap.get(event.categoryName) ?? [];
eventCategoryMap.set(event.categoryName, [...existingEvents, event]);
}
registerEventCategories(client, eventCategoryMap) {
for (const [categoryName, events] of eventCategoryMap) {
const sortedEvents = this.sortEventsByRunOrder(events);
const categoryFunction = this.createCategoryRunner(sortedEvents);
client.on(categoryName, categoryFunction);
this.eventMap.set(categoryName, {
events: sortedEvents,
categoryFunction,
});
(0, logger_1.logInfo)(`Event category '${categoryName}' registered with ${sortedEvents.length.toString()} ${sortedEvents.length === 1 ? "event" : "events"}.`);
}
}
sortEventsByRunOrder(events) {
const orderedEvents = events
.filter(event => event.runOrder !== undefined)
.sort((a, b) => (a.runOrder ?? 0) - (b.runOrder ?? 0));
const unorderedEvents = events.filter(event => event.runOrder === undefined);
return [...orderedEvents, ...unorderedEvents];
}
logRegistrationSummary() {
const totalEvents = Array.from(this.eventMap.values())
.reduce((total, eventList) => total + eventList.events.length, 0);
(0, logger_1.logInfo)(`${totalEvents.toString()} ${totalEvents === 1 ? "event" : "events"} registered successfully.`);
}
createCategoryRunner(events) {
return (...args) => {
for (const event of events) {
try {
event.run(...args);
}
catch (error) {
(0, logger_1.logError)(`Event execution failed for category '${event.categoryName}'`);
console.error(error);
}
}
};
}
getEvents() {
return Array.from(this.eventMap.values()).flatMap(eventList => eventList.events);
}
getEventCategory(eventName) {
return this.eventMap.get(eventName);
}
clearEvents(client) {
for (const [categoryName, { categoryFunction }] of this.eventMap) {
client.removeListener(categoryName, categoryFunction);
}
this.eventMap.clear();
}
}
exports.EventHandler = EventHandler;