seyfert 1.4.0 → 1.5.0

package/lib/common/shorters/bans.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BanShorter = void 0;
+const base_1 = require("./base");
+const GuildBan_1 = require("../../structures/GuildBan");
+class BanShorter extends base_1.BaseShorter {
+    /**
+     * Bulk creates bans in the guild.
+     * @param guildId The ID of the guild.
+     * @param body The request body for bulk banning members.
+     * @param reason The reason for bulk banning members.
+     */
+    async bulkCreate(guildId, body, reason) {
+        const bans = await this.client.proxy.guilds(guildId)['bulk-bans'].post({ reason, body });
+        for (const id of bans.banned_users)
+            this.client.cache.members?.removeIfNI('GuildBans', id, guildId);
+        return bans;
+    }
+    /**
+     * Unbans a member from the guild.
+     * @param guildId The ID of the guild.
+     * @param memberId The ID of the member to unban.
+     * @param reason The reason for unbanning the member.
+     */
+    async remove(guildId, memberId, reason) {
+        await this.client.proxy.guilds(guildId).bans(memberId).delete({ reason });
+    }
+    /**
+     * Bans a member from the guild.
+     * @param guildId The ID of the guild.
+     * @param memberId The ID of the member to ban.
+     * @param body The request body for banning the member.
+     * @param reason The reason for banning the member.
+     */
+    async create(guildId, memberId, body, reason) {
+        await this.client.proxy.guilds(guildId).bans(memberId).put({ reason, body });
+        await this.client.cache.members?.removeIfNI('GuildBans', memberId, guildId);
+    }
+    /**
+     * Fetches a ban from the guild.
+     * @param guildId The ID of the guild.
+     * @param userId The ID of the user to fetch.
+     * @param force Whether to force fetching the ban from the API even if it exists in the cache.
+     * @returns A Promise that resolves to the fetched ban.
+     */
+    async fetch(guildId, userId, force = false) {
+        let ban;
+        if (!force) {
+            ban = await this.client.cache.bans?.get(userId, guildId);
+            if (ban)
+                return ban;
+        }
+        ban = await this.client.proxy.guilds(guildId).bans(userId).get();
+        await this.client.cache.members?.set(ban.user.id, guildId, ban);
+        return new GuildBan_1.GuildBan(this.client, ban, guildId);
+    }
+    /**
+     * Lists bans in the guild based on the provided query.
+     * @param guildId The ID of the guild.
+     * @param query The query parameters for listing bans.
+     * @param force Whether to force listing bans from the API even if they exist in the cache.
+     * @returns A Promise that resolves to an array of listed bans.
+     */
+    async list(guildId, query, force = false) {
+        let bans;
+        if (!force) {
+            bans = (await this.client.cache.bans?.values(guildId)) ?? [];
+            if (bans.length)
+                return bans;
+        }
+        bans = await this.client.proxy.guilds(guildId).bans.get({
+            query,
+        });
+        await this.client.cache.bans?.set(bans.map(x => [x.user.id, x]), guildId);
+        return bans.map(m => new GuildBan_1.GuildBan(this.client, m, guildId));
+    }
+}
+exports.BanShorter = BanShorter;

package/lib/common/shorters/emojis.d.ts

@@ -19,7 +19,7 @@ export declare class EmojiShorter extends BaseShorter {
      */
     create(guildId: string, body: OmitInsert<RESTPostAPIGuildEmojiJSONBody, 'image', {
         image: ImageResolvable;
-    }>): Promise<void>;
+    }>): Promise<GuildEmoji>;
     /**
      * Fetches an emoji by its ID.
      * @param guildId The ID of the guild.

package/lib/common/shorters/emojis.js

@@ -34,7 +34,8 @@ class EmojiShorter extends base_1.BaseShorter {
         const emoji = await this.client.proxy.guilds(guildId).emojis.post({
             body: bodyResolved,
         });
-        await this.client.cache.channels?.setIfNI('GuildEmojisAndStickers', emoji.id, guildId, emoji);
+        await this.client.cache.emojis?.setIfNI('GuildEmojisAndStickers', emoji.id, guildId, emoji);
+        return new __1.GuildEmoji(this.client, emoji, guildId);
     }
     /**
      * Fetches an emoji by its ID.
@@ -61,7 +62,7 @@ class EmojiShorter extends base_1.BaseShorter {
      */
     async delete(guildId, emojiId, reason) {
         await this.client.proxy.guilds(guildId).emojis(emojiId).delete({ reason });
-        await this.client.cache.channels?.removeIfNI('GuildEmojisAndStickers', emojiId, guildId);
+        await this.client.cache.emojis?.removeIfNI('GuildEmojisAndStickers', emojiId, guildId);
     }
     /**
      * Edits an emoji in the guild.
@@ -73,7 +74,7 @@ class EmojiShorter extends base_1.BaseShorter {
      */
     async edit(guildId, emojiId, body, reason) {
         const emoji = await this.client.proxy.guilds(guildId).emojis(emojiId).patch({ body, reason });
-        await this.client.cache.channels?.setIfNI('GuildEmojisAndStickers', emoji.id, guildId, emoji);
+        await this.client.cache.emojis?.setIfNI('GuildEmojisAndStickers', emoji.id, guildId, emoji);
         return new __1.GuildEmoji(this.client, emoji, guildId);
     }
 }

package/lib/common/shorters/interaction.js

@@ -9,14 +9,15 @@ class InteractionShorter extends base_1.BaseShorter {
         const { files, ...rest } = body.data ?? {};
         //@ts-expect-error
         const data = body.data instanceof __1.Modal ? body.data : rest;
+        const parsedFiles = files ? await (0, __1.resolveFiles)(files) : undefined;
         return this.client.proxy
             .interactions(id)(token)
             .callback.post({
             body: __1.BaseInteraction.transformBodyRequest({
                 type: body.type,
                 data,
-            }, this.client),
-            files: files ? await (0, __1.resolveFiles)(files) : undefined,
+            }, parsedFiles, this.client),
+            files: parsedFiles,
         });
     }
     fetchResponse(token, messageId) {
@@ -27,12 +28,13 @@ class InteractionShorter extends base_1.BaseShorter {
     }
     async editMessage(token, messageId, body) {
         const { files, ...data } = body;
+        const parsedFiles = files ? await (0, __1.resolveFiles)(files) : undefined;
         const apiMessage = await this.client.proxy
             .webhooks(this.client.applicationId)(token)
             .messages(messageId)
             .patch({
-            body: __1.BaseInteraction.transformBody(data, this.client),
-            files: files ? await (0, __1.resolveFiles)(files) : undefined,
+            body: __1.BaseInteraction.transformBody(data, parsedFiles, this.client),
+            files: parsedFiles,
         });
         return new __1.WebhookMessage(this.client, apiMessage, this.client.applicationId, token);
     }
@@ -50,12 +52,12 @@ class InteractionShorter extends base_1.BaseShorter {
         return this.deleteResponse(interactionId, token, '@original');
     }
     async followup(token, { files, ...body }) {
-        files = files ? await (0, __1.resolveFiles)(files) : undefined;
+        const parsedFiles = files ? await (0, __1.resolveFiles)(files) : undefined;
         const apiMessage = await this.client.proxy
             .webhooks(this.client.applicationId)(token)
             .post({
-            body: __1.BaseInteraction.transformBody(body, this.client),
-            files: files,
+            body: __1.BaseInteraction.transformBody(body, parsedFiles, this.client),
+            files: parsedFiles,
         });
         return new __1.WebhookMessage(this.client, apiMessage, this.client.applicationId, token);
     }

package/lib/common/shorters/messages.js

@@ -7,7 +7,7 @@ const base_1 = require("./base");
 class MessageShorter extends base_1.BaseShorter {
     async write(channelId, { files, ...body }) {
         const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
-        const transformedBody = structures_1.MessagesMethods.transformMessageBody(body, this.client);
+        const transformedBody = structures_1.MessagesMethods.transformMessageBody(body, parsedFiles, this.client);
         return this.client.proxy
             .channels(channelId)
             .messages.post({
@@ -25,7 +25,7 @@ class MessageShorter extends base_1.BaseShorter {
             .channels(channelId)
             .messages(messageId)
             .patch({
-            body: structures_1.MessagesMethods.transformMessageBody(body, this.client),
+            body: structures_1.MessagesMethods.transformMessageBody(body, parsedFiles, this.client),
             files: parsedFiles,
         })
             .then(async (message) => {

package/lib/common/shorters/webhook.js

@@ -67,8 +67,8 @@ class WebhookShorter extends base_1.BaseShorter {
      */
     async writeMessage(webhookId, token, { body: data, ...payload }) {
         const { files, ...body } = data;
-        const transformedBody = structures_1.MessagesMethods.transformMessageBody(body, this.client);
         const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
+        const transformedBody = structures_1.MessagesMethods.transformMessageBody(body, parsedFiles, this.client);
         return this.client.proxy
             .webhooks(webhookId)(token)
             .post({ ...payload, files: parsedFiles, body: transformedBody })
@@ -84,8 +84,8 @@ class WebhookShorter extends base_1.BaseShorter {
      */
     async editMessage(webhookId, token, { messageId, body: data, ...json }) {
         const { files, ...body } = data;
-        const transformedBody = structures_1.MessagesMethods.transformMessageBody(body, this.client);
         const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
+        const transformedBody = structures_1.MessagesMethods.transformMessageBody(body, parsedFiles, this.client);
         return this.client.proxy
             .webhooks(webhookId)(token)
             .messages(messageId)

package/lib/components/componentcommand.d.ts

@@ -1,5 +1,5 @@
 import type { ContextComponentCommandInteractionMap, ComponentContext } from './componentcontext';
-import type { RegisteredMiddlewares, UsingClient } from '../commands';
+import type { ExtraProps, RegisteredMiddlewares, UsingClient } from '../commands';
 export declare const InteractionCommandType: {
     readonly COMPONENT: 0;
     readonly MODAL: 1;
@@ -12,10 +12,11 @@ export declare abstract class ComponentCommand {
     abstract componentType: keyof ContextComponentCommandInteractionMap;
     abstract filter(context: ComponentContext<typeof this.componentType>): Promise<boolean> | boolean;
     abstract run(context: ComponentContext<typeof this.componentType>): any;
+    middlewares: (keyof RegisteredMiddlewares)[];
+    props: ExtraProps;
     get cType(): number;
     onAfterRun?(context: ComponentContext, error: unknown | undefined): any;
     onRunError?(context: ComponentContext, error: unknown): any;
     onMiddlewaresError?(context: ComponentContext, error: string): any;
     onInternalError?(client: UsingClient, error?: unknown): any;
-    middlewares: (keyof RegisteredMiddlewares)[];
 }

package/lib/components/componentcommand.js

@@ -8,9 +8,10 @@ exports.InteractionCommandType = {
 };
 class ComponentCommand {
     type = exports.InteractionCommandType.COMPONENT;
+    middlewares = [];
+    props;
     get cType() {
         return v10_1.ComponentType[this.componentType];
     }
-    middlewares = [];
 }
 exports.ComponentCommand = ComponentCommand;

package/lib/components/componentcontext.d.ts

@@ -17,7 +17,7 @@ export declare class ComponentContext<Type extends keyof ContextComponentCommand
      * @param interaction - The component interaction object.
      */
     constructor(client: UsingClient, interaction: ContextComponentCommandInteractionMap[Type]);
-    command?: ComponentCommand;
+    command: ComponentCommand;
     metadata: CommandMetadata<UnionToTuple<M>>;
     globalMetadata: GlobalMetadata;
     /**

package/lib/components/handler.d.ts

@@ -42,7 +42,7 @@ export declare class ComponentHandler extends BaseHandler {
         new (): ModalCommand | ComponentCommand;
     }[]): Promise<void>;
     reload(path: string): Promise<any>;
-    reloadAll(): Promise<void>;
+    reloadAll(stopIfFail?: boolean): Promise<void>;
     executeComponent(context: ComponentContext): Promise<any>;
     executeModal(context: ModalContext): Promise<any>;
     setHandlers({ callback }: {

package/lib/components/handler.js

@@ -22,7 +22,7 @@ class ComponentHandler extends common_1.BaseHandler {
         this.values.set(messageId, {
             components: [],
             options,
-            idle: options.idle
+            idle: options.idle && options.idle > 0
                 ? setTimeout(() => {
                     this.deleteValue(messageId);
                     options.onStop?.('idle', () => {
@@ -30,7 +30,7 @@ class ComponentHandler extends common_1.BaseHandler {
                     });
                 }, options.idle)
                 : undefined,
-            timeout: options.timeout
+            timeout: options.timeout && options.timeout > 0
                 ? setTimeout(() => {
                     this.deleteValue(messageId);
                     options.onStop?.('timeout', () => {
@@ -122,39 +122,33 @@ class ComponentHandler extends common_1.BaseHandler {
             const i = new x();
             return { file: x, path: i.__filePath ?? '*' };
         }) ?? (await this.loadFilesK(await this.getFiles(componentsDir)));
-        for (let i = 0; i < paths.length; i++) {
+        for (const value of paths) {
             let component;
             try {
-                component = this.callback(paths[i].file);
+                component = this.callback(value.file);
                 if (!component)
                     continue;
             }
             catch (e) {
                 if (e instanceof Error && e.message.includes('is not a constructor')) {
-                    this.logger.warn(`${paths[i].path
+                    this.logger.warn(`${value.path
                         .split(process.cwd())
                         .slice(1)
                         .join(process.cwd())} doesn't export the class by \`export default <ComponentCommand>\``);
                 }
                 else
-                    this.logger.warn(e, paths[i]);
+                    this.logger.warn(e, value);
                 continue;
             }
-            if (!(component instanceof modalcommand_1.ModalCommand) && !(component instanceof componentcommand_1.ComponentCommand))
+            if (!(component instanceof modalcommand_1.ModalCommand || component instanceof componentcommand_1.ComponentCommand))
                 continue;
-            if (component instanceof modalcommand_1.ModalCommand) {
-                component.onInternalError ??= this.client.options?.modals?.defaults?.onInternalError;
-                component.onMiddlewaresError ??= this.client.options?.modals?.defaults?.onMiddlewaresError;
-                component.onRunError ??= this.client.options?.modals?.defaults?.onRunError;
-                component.onAfterRun ??= this.client.options?.modals?.defaults?.onAfterRun;
-            }
-            else {
-                component.onInternalError ??= this.client.options?.components?.defaults?.onInternalError;
-                component.onMiddlewaresError ??= this.client.options?.components?.defaults?.onMiddlewaresError;
-                component.onRunError ??= this.client.options?.components?.defaults?.onRunError;
-                component.onAfterRun ??= this.client.options?.components?.defaults?.onAfterRun;
-            }
-            component.__filePath = paths[i].path;
+            component.props ??= this.client.options.commands?.defaults?.props ?? {};
+            const is = component instanceof modalcommand_1.ModalCommand ? 'modals' : 'components';
+            component.onInternalError ??= this.client.options?.[is]?.defaults?.onInternalError;
+            component.onMiddlewaresError ??= this.client.options?.[is]?.defaults?.onMiddlewaresError;
+            component.onRunError ??= this.client.options?.[is]?.defaults?.onRunError;
+            component.onAfterRun ??= this.client.options?.[is]?.defaults?.onAfterRun;
+            component.__filePath = value.path;
             this.commands.push(component);
         }
     }
@@ -165,7 +159,7 @@ class ComponentHandler extends common_1.BaseHandler {
             x.__filePath?.endsWith(`${path}.ts`) ||
             x.__filePath?.endsWith(path) ||
             x.__filePath === path);
-        if (!component || !component.__filePath)
+        if (!component?.__filePath)
             return null;
         delete require.cache[component.__filePath];
         const index = this.client.components.commands.findIndex(x => x.__filePath === component.__filePath);
@@ -178,13 +172,16 @@ class ComponentHandler extends common_1.BaseHandler {
         this.client.components.commands.push(command);
         return imported;
     }
-    async reloadAll() {
-        if (!this.client.components)
-            return;
-        for (const i of this.client.components.commands) {
-            if (!i.__filePath)
-                return this.logger.warn('Unknown command dont have __filePath property', i);
-            await this.reload(i.__filePath);
+    async reloadAll(stopIfFail = true) {
+        for (const i of this.commands) {
+            try {
+                await this.reload(i.__filePath ?? '');
+            }
+            catch (e) {
+                if (stopIfFail) {
+                    throw e;
+                }
+            }
         }
     }
     async executeComponent(context) {

package/lib/components/modalcommand.d.ts

@@ -1,4 +1,4 @@
-import type { RegisteredMiddlewares, UsingClient } from '../commands';
+import type { ExtraProps, RegisteredMiddlewares, UsingClient } from '../commands';
 import type { ModalContext } from './modalcontext';
 export interface ModalCommand {
     __filePath?: string;
@@ -8,6 +8,7 @@ export declare abstract class ModalCommand {
     abstract filter(context: ModalContext): Promise<boolean> | boolean;
     abstract run(context: ModalContext): any;
     middlewares: (keyof RegisteredMiddlewares)[];
+    props: ExtraProps;
     onAfterRun?(context: ModalContext, error: unknown | undefined): any;
     onRunError?(context: ModalContext, error: unknown): any;
     onMiddlewaresError?(context: ModalContext, error: string): any;

package/lib/components/modalcommand.js

@@ -5,5 +5,6 @@ const componentcommand_1 = require("./componentcommand");
 class ModalCommand {
     type = componentcommand_1.InteractionCommandType.MODAL;
     middlewares = [];
+    props;
 }
 exports.ModalCommand = ModalCommand;

package/lib/components/modalcontext.d.ts

@@ -17,7 +17,7 @@ export declare class ModalContext<M extends keyof RegisteredMiddlewares = never>
      * @param interaction - The component interaction object.
      */
     constructor(client: UsingClient, interaction: ModalSubmitInteraction);
-    command?: ModalCommand;
+    command: ModalCommand;
     metadata: CommandMetadata<UnionToTuple<M>>;
     globalMetadata: GlobalMetadata;
     get customId(): string;

package/lib/events/event.d.ts

@@ -1,16 +1,17 @@
 import type { UsingClient } from '../commands';
 import type { ClientEvents } from './hooks';
-export interface DeclareEventsOptions {
-    name: `${keyof ClientEvents}`;
-    once?: boolean;
+export interface CustomEvents {
 }
 export type ClientNameEvents = Extract<keyof ClientEvents, string>;
+export type CustomEventsKeys = Extract<keyof CustomEvents, string>;
 export interface ClientDataEvent {
     name: ClientNameEvents;
     once: boolean;
 }
 export type CallbackEventHandler = {
     [K in keyof ClientEvents]: (...data: [Awaited<ClientEvents[K]>, UsingClient, number]) => unknown;
+} & {
+    [K in keyof CustomEvents]: (...data: [Parameters<CustomEvents[K]>, UsingClient, number]) => unknown;
 };
 export type EventContext<T extends {
     data: {

package/lib/events/handler.d.ts

@@ -2,23 +2,26 @@ import type { GatewayDispatchPayload } from 'discord-api-types/v10';
 import type { Client, WorkerClient } from '../client';
 import { BaseHandler, type MakeRequired, type SnakeCase } from '../common';
 import type { ClientEvents } from '../events/hooks';
-import type { ClientEvent, ClientNameEvents } from './event';
+import type { ClientEvent, CustomEvents, CustomEventsKeys } from './event';
 export type EventValue = MakeRequired<ClientEvent, '__filePath'> & {
     fired?: boolean;
 };
 export type GatewayEvents = Uppercase<SnakeCase<keyof ClientEvents>>;
 export declare class EventHandler extends BaseHandler {
-    onFail: (event: GatewayEvents, err: unknown) => void;
+    protected client: Client | WorkerClient;
+    constructor(client: Client | WorkerClient);
+    onFail: (event: GatewayEvents | CustomEventsKeys, err: unknown) => void;
     protected filter: (path: string) => boolean;
-    values: Partial<Record<GatewayEvents, EventValue>>;
+    values: Partial<Record<GatewayEvents | CustomEventsKeys, EventValue>>;
     load(eventsDir: string, instances?: {
         file: ClientEvent;
         path: string;
     }[]): Promise<void>;
     execute(name: GatewayEvents, ...args: [GatewayDispatchPayload, Client<true> | WorkerClient<true>, number]): Promise<void>;
     runEvent(name: GatewayEvents, client: Client | WorkerClient, packet: any, shardId: number): Promise<void>;
-    reload(name: ClientNameEvents): Promise<any>;
-    reloadAll(): Promise<void>;
+    runCustom<T extends CustomEventsKeys>(name: T, ...args: Parameters<CustomEvents[T]>): Promise<void>;
+    reload(name: GatewayEvents | CustomEventsKeys): Promise<any>;
+    reloadAll(stopIfFail?: boolean): Promise<void>;
     setHandlers({ callback }: {
         callback: EventHandler['callback'];
     }): void;

package/lib/events/handler.js

@@ -27,10 +27,16 @@ exports.EventHandler = void 0;
 const common_1 = require("../common");
 const RawEvents = __importStar(require("../events/hooks"));
 class EventHandler extends common_1.BaseHandler {
+    client;
+    constructor(client) {
+        super(client.logger);
+        this.client = client;
+    }
     onFail = (event, err) => this.logger.warn('<Client>.events.onFail', err, event);
     filter = (path) => path.endsWith('.js') || (!path.endsWith('.d.ts') && path.endsWith('.ts'));
     values = {};
     async load(eventsDir, instances) {
+        const discordEvents = Object.keys(RawEvents).map(x => common_1.ReplaceRegex.camel(x.toLowerCase()));
         for (const i of instances ?? (await this.loadFilesK(await this.getFiles(eventsDir)))) {
             const instance = this.callback(i.file);
             if (!instance)
@@ -40,7 +46,9 @@ class EventHandler extends common_1.BaseHandler {
                 continue;
             }
             instance.__filePath = i.path;
-            this.values[common_1.ReplaceRegex.snake(instance.data.name).toUpperCase()] = instance;
+            this.values[discordEvents.includes(instance.data.name)
+                ? common_1.ReplaceRegex.snake(instance.data.name).toUpperCase()
+                : instance.data.name] = instance;
         }
     }
     async execute(name, ...args) {
@@ -48,8 +56,8 @@ class EventHandler extends common_1.BaseHandler {
             case 'MESSAGE_CREATE':
                 {
                     const { d: data } = args[0];
-                    if (args[1].components?.values.has(data.interaction?.id ?? data.id)) {
-                        args[1].components.values.get(data.interaction?.id ?? data.id).messageId = data.id;
+                    if (args[1].components?.values.has(data.interaction_metadata?.id ?? data.id)) {
+                        args[1].components.values.get(data.interaction_metadata?.id ?? data.id).messageId = data.id;
                     }
                 }
                 break;
@@ -75,39 +83,76 @@ class EventHandler extends common_1.BaseHandler {
                 }
                 break;
         }
-        await this.runEvent(args[0].t, args[1], args[0].d, args[2]);
+        await Promise.all([
+            this.runEvent(args[0].t, args[1], args[0].d, args[2]),
+            this.client.collectors.run(args[0].t, args[0].d),
+        ]);
     }
     async runEvent(name, client, packet, shardId) {
         const Event = this.values[name];
         if (!Event) {
-            return;
+            return this.client.cache.onPacket({
+                t: name,
+                d: packet,
+            });
         }
         try {
             if (Event.data.once && Event.fired) {
-                return;
+                return this.client.cache.onPacket({
+                    t: name,
+                    d: packet,
+                });
             }
             Event.fired = true;
             const hook = await RawEvents[name]?.(client, packet);
-            await Event.run(...[hook, client, shardId]);
+            if (name !== 'RAW')
+                await this.client.cache.onPacket({
+                    t: name,
+                    d: packet,
+                });
+            await Event.run(hook, client, shardId);
+        }
+        catch (e) {
+            await this.onFail(name, e);
+        }
+    }
+    async runCustom(name, ...args) {
+        const Event = this.values[name];
+        if (!Event) {
+            return this.client.collectors.run(name, args);
+        }
+        try {
+            if (Event.data.once && Event.fired) {
+                return this.client.collectors.run(name, args);
+            }
+            Event.fired = true;
+            this.logger.debug(`executed a custom event [${name}]`, Event.data.once ? 'once' : '');
+            await Promise.all([Event.run(args, this.client), this.client.collectors.run(name, args)]);
         }
         catch (e) {
             await this.onFail(name, e);
         }
     }
     async reload(name) {
-        const eventName = common_1.ReplaceRegex.snake(name).toUpperCase();
-        const event = this.values[eventName];
-        if (!event)
+        const event = this.values[name];
+        if (!event?.__filePath)
             return null;
         delete require.cache[event.__filePath];
         const imported = await (0, common_1.magicImport)(event.__filePath).then(x => x.default ?? x);
         imported.__filePath = event.__filePath;
-        this.values[eventName] = imported;
+        this.values[name] = imported;
         return imported;
     }
-    async reloadAll() {
+    async reloadAll(stopIfFail = true) {
         for (const i in this.values) {
-            await this.reload(common_1.ReplaceRegex.camel(i));
+            try {
+                await this.reload(i);
+            }
+            catch (e) {
+                if (stopIfFail) {
+                    throw e;
+                }
+            }
         }
     }
     setHandlers({ callback }) {