seyfert 4.5.0 → 5.0.0

package/lib/components/modalcontext.js

@@ -23,17 +23,64 @@ class ModalContext extends basecontext_1.BaseContext {
     command;
     metadata = {};
     globalMetadata = {};
-    get customId() {
-        return this.interaction.customId;
-    }
     get components() {
         return this.interaction.components;
     }
+    get customId() {
+        return this.interaction.customId;
+    }
     /**
      * Gets the language object for the interaction's locale.
      */
     get t() {
-        return this.client.t(this.interaction.locale ?? this.client.langs.defaultLang ?? 'en-US');
+        return this.client.t(this.client.langs.preferGuildLocale
+            ? (this.interaction.guildLocale ?? this.interaction.locale ?? this.client.langs.defaultLang ?? 'en-US')
+            : (this.interaction.locale ?? this.client.langs.defaultLang ?? 'en-US'));
+    }
+    getChannels(customId, required) {
+        if (required)
+            return this.interaction.getChannels(customId, true);
+        return this.interaction.getChannels(customId);
+    }
+    getRoles(customId, required) {
+        if (required)
+            return this.interaction.getRoles(customId, true);
+        return this.interaction.getRoles(customId);
+    }
+    getUsers(customId, required) {
+        if (required)
+            return this.interaction.getUsers(customId, true);
+        return this.interaction.getUsers(customId);
+    }
+    getMentionables(customId, required) {
+        if (required)
+            return this.interaction.getMentionables(customId, true);
+        return this.interaction.getMentionables(customId);
+    }
+    getRadioValues(customId, required) {
+        if (required)
+            return this.interaction.getRadioValues(customId, true);
+        return this.interaction.getRadioValues(customId);
+    }
+    getCheckboxValues(customId, required) {
+        if (required)
+            return this.interaction.getCheckboxValues(customId, true);
+        return this.interaction.getCheckboxValues(customId);
+    }
+    getCheckbox(customId, required) {
+        if (required)
+            return this.interaction.getCheckbox(customId, true);
+        return this.interaction.getCheckbox(customId);
+    }
+    getInputValue(customId, required) {
+        if (required)
+            return this.interaction.getInputValue(customId, true);
+        return this.interaction.getInputValue(customId);
+    }
+    getFiles(customId, required) {
+        if (required)
+            return this.interaction.getFiles(customId, true);
+        return this.interaction.getFiles(customId);
     }
     /**
      * Writes a response to the interaction.
@@ -50,6 +97,12 @@ class ModalContext extends basecontext_1.BaseContext {
     deferReply(ephemeral = false, fetchReply) {
         return this.interaction.deferReply(ephemeral ? types_1.MessageFlags.Ephemeral : undefined, fetchReply);
     }
+    update(body, withResponse) {
+        return this.interaction.update(body, withResponse);
+    }
+    deferUpdate() {
+        return this.interaction.deferUpdate();
+    }
     /**
      * Edits the response of the interaction.
      * @param body - The updated body of the response.
@@ -100,14 +153,14 @@ class ModalContext extends basecontext_1.BaseContext {
                 return this.client.members.fetch(this.guildId, this.client.botId, mode === 'rest');
         }
     }
-    guild(mode = 'flow') {
+    guild(mode = 'flow', query) {
         if (!this.guildId)
             return (mode === 'cache' ? (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined) : Promise.resolve());
         switch (mode) {
             case 'cache':
                 return this.client.cache.guilds?.get(this.guildId);
             default:
-                return this.client.guilds.fetch(this.guildId, mode === 'rest');
+                return this.client.guilds.fetch(this.guildId, { force: mode === 'rest', query });
         }
     }
     /**

package/lib/events/event.d.ts

@@ -1,6 +1,12 @@
-import type { UsingClient } from '../commands';
+import type { PluginLoadedMetadata, PluginUploadCommandsMetadata } from '../client/plugins';
+import type { Command, ContextMenuCommand, EntryPointCommand, UsingClient } from '../commands';
+import type { Awaitable } from '../common';
+import type { ComponentCommands } from '../components/handler';
 import type { ClientEvents } from './hooks';
 export interface CustomEvents {
+    commandsLoaded: (metadata: PluginLoadedMetadata<'commands', Command | ContextMenuCommand | EntryPointCommand>) => void;
+    componentsLoaded: (metadata: PluginLoadedMetadata<'components', ComponentCommands>) => void;
+    uploadCommands: (metadata: PluginUploadCommandsMetadata) => void;
 }
 export type ClientNameEvents = Extract<keyof ClientEvents, string>;
 export type CustomEventsKeys = Extract<keyof CustomEvents, string>;
@@ -11,7 +17,7 @@ export interface ClientDataEvent {
 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;
+    [K in keyof CustomEvents]: (...data: [...Parameters<CustomEvents[K]>, UsingClient]) => unknown;
 };
 export type EventContext<T extends {
     data: {
@@ -20,5 +26,5 @@ export type EventContext<T extends {
 }> = Parameters<CallbackEventHandler[T['data']['name']]>;
 export interface ClientEvent {
     data: ClientDataEvent;
-    run(...args: EventContext<any>): any;
+    run(...args: EventContext<any>): Awaitable<unknown>;
 }

package/lib/events/handler.d.ts

@@ -1,7 +1,9 @@
 import type { Client, WorkerClient } from '../client';
+import type { BaseClient } from '../client/base';
+import { type PluginOrderedContribution } from '../client/plugins/order';
 import type { UsingClient } from '../commands';
 import type { FileLoaded } from '../commands/handler';
-import { BaseHandler, type CamelCase, type MakeRequired, type SnakeCase } from '../common';
+import { type Awaitable, BaseHandler, type CamelCase, type MakeRequired, type SnakeCase } from '../common';
 import type { ClientEvents } from '../events/hooks';
 import { type GatewayDispatchPayload } from '../types';
 import type { ClientEvent, ClientNameEvents, CustomEvents, CustomEventsKeys, EventContext } from './event';
@@ -29,23 +31,66 @@ export type ResolveEventRunParams<T extends ClientNameEvents | CustomEventsKeys
 }> : never;
 export type EventValues = {
     [K in CustomEventsKeys | GatewayEvents]: Omit<EventValue, 'run'> & {
-        run(...args: ResolveEventRunParams<K>): any;
+        run(...args: ResolveEventRunParams<K>): Awaitable<unknown>;
     };
 };
-export declare class EventHandler extends BaseHandler {
+export interface CustomEventRunner {
+    emit<T extends CustomEventsKeys>(name: T, ...args: ResolveEventRunParams<T>): Awaitable<void>;
+    runCustom<T extends CustomEventsKeys>(name: T, ...args: ResolveEventRunParams<T>): Awaitable<void>;
+}
+type PluginEventListener = PluginOrderedContribution & {
+    record: {
+        plugin: {
+            name: string;
+            instanceId?: string;
+        };
+        index: number;
+    };
+    name: string;
+    handler: (...args: unknown[]) => unknown;
+    active: boolean;
+    once?: boolean;
+    fired?: boolean;
+};
+type PluginAnyEventListener = PluginOrderedContribution & {
+    record: {
+        plugin: {
+            name: string;
+            instanceId?: string;
+        };
+        index: number;
+    };
+    handler: (name: string, ...args: unknown[]) => unknown;
+    active: boolean;
+};
+type ClientWithPluginRegistry = BaseClient;
+export declare class CustomEventHandler extends BaseHandler implements CustomEventRunner {
+    protected client: ClientWithPluginRegistry;
+    constructor(client: ClientWithPluginRegistry);
+    onFail: (event: GatewayEvents | CustomEventsKeys | string, err: unknown) => void;
+    values: Partial<EventValues>;
+    emit<T extends CustomEventsKeys>(name: T, ...args: ResolveEventRunParams<T>): Promise<void>;
+    runCustom<T extends CustomEventsKeys>(name: T, ...args: ResolveEventRunParams<T>): Promise<void>;
+    protected getPluginListeners(name: string): import("../client/plugins/registry").PluginEventContribution[];
+    protected getPluginAnyListeners(): import("../client/plugins/registry").PluginAnyEventContribution[];
+    protected getPluginErrorListeners(): import("../client/plugins/registry").PluginEventErrorContribution[];
+    protected runCollectors(name: string, args: unknown): unknown;
+    protected createPluginListenerTask(name: string, listeners: readonly PluginEventListener[], anyListeners: readonly PluginAnyEventListener[], args: readonly unknown[]): Promise<void> | undefined;
+    protected settleEventTasks(name: GatewayEvents | CustomEventsKeys | string, tasks: readonly Promise<unknown>[]): Promise<void>;
+    protected reportEventFailure(name: GatewayEvents | CustomEventsKeys | string, error: unknown): Promise<void>;
+}
+export declare class EventHandler extends CustomEventHandler {
     protected client: Client | WorkerClient;
     constructor(client: Client | WorkerClient);
-    onFail: (event: GatewayEvents | CustomEventsKeys, err: unknown) => void;
     filter: (path: string) => boolean;
-    values: Partial<EventValues>;
     discordEvents: ClientNameEvents[];
     set(events: ClientEvent[]): void;
     load(eventsDir: string): Promise<void>;
     execute(raw: GatewayDispatchPayload, client: Client<true> | WorkerClient<true>, shardId: number): Promise<void>;
     runEvent(name: GatewayEvents, client: Client | WorkerClient, packet: unknown, shardId: number, runCache?: boolean): Promise<void>;
-    runCustom<T extends CustomEventsKeys>(name: T, ...args: ResolveEventRunParams<T>): Promise<void>;
     reload(name: GatewayEvents | CustomEventsKeys): Promise<any>;
     reloadAll(stopIfFail?: boolean): Promise<void>;
     onFile(file: FileLoaded<ClientEvent>): ClientEvent[] | undefined;
     callback: (file: ClientEvent) => ClientEvent | false;
 }
+export {};

package/lib/events/handler.js

@@ -33,19 +33,141 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventHandler = void 0;
+exports.EventHandler = exports.CustomEventHandler = void 0;
+const errors_1 = require("../client/plugins/errors");
+const order_1 = require("../client/plugins/order");
 const common_1 = require("../common");
 const RawEvents = __importStar(require("../events/hooks"));
+const utils_1 = require("../events/utils");
 const types_1 = require("../types");
-class EventHandler extends common_1.BaseHandler {
+class CustomEventHandler 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 = {};
+    emit(name, ...args) {
+        return this.runCustom(name, ...args);
+    }
+    async runCustom(name, ...args) {
+        const listeners = this.getPluginListeners(name);
+        const anyListeners = this.getPluginAnyListeners();
+        const Event = this.values[name];
+        try {
+            if ((!Event || (Event.data.once && Event.fired)) && !listeners.length && !anyListeners.length) {
+                await this.runCollectors(name, args);
+                return;
+            }
+            this.client.debugger?.debug(`executed a custom event [${name}]`, Event?.data.once ? 'once' : '');
+            const tasks = [];
+            const collectors = this.runCollectors(name, args);
+            if (collectors)
+                tasks.push(Promise.resolve(collectors));
+            if (Event && !(Event.data.once && Event.fired)) {
+                if (Event.data.once) {
+                    Event.fired = true;
+                    tasks.push(Promise.resolve()
+                        .then(() => Event.run(...args, this.client))
+                        .catch(error => {
+                        Event.fired = false;
+                        throw error;
+                    }));
+                }
+                else {
+                    tasks.push(Promise.resolve(Event.run(...args, this.client)));
+                }
+            }
+            const pluginTask = this.createPluginListenerTask(name, listeners, anyListeners, [...args, this.client]);
+            if (pluginTask)
+                tasks.push(pluginTask);
+            await this.settleEventTasks(name, tasks);
+        }
+        catch (e) {
+            await this.reportEventFailure(name, e);
+        }
+    }
+    getPluginListeners(name) {
+        const normalized = (0, utils_1.normalizeEventName)(name);
+        return ((0, order_1.orderedPluginContributions)((this.client.pluginRegistry?.events ?? []).filter(listener => listener.active && (0, utils_1.normalizeEventName)(listener.name) === normalized)) ?? []);
+    }
+    getPluginAnyListeners() {
+        return (0, order_1.orderedPluginContributions)((this.client.pluginRegistry?.anyEvents ?? []).filter(listener => listener.active));
+    }
+    getPluginErrorListeners() {
+        return (0, order_1.orderedPluginContributions)((this.client.pluginRegistry?.eventErrors ?? []).filter(listener => listener.active));
+    }
+    runCollectors(name, args) {
+        return this.client.collectors?.run(name, args, this.client);
+    }
+    // Plugin listeners are additive and ordered as one sequence across exact and onAny listeners.
+    createPluginListenerTask(name, listeners, anyListeners, args) {
+        const entries = [
+            ...listeners.map(listener => ({
+                listener,
+                listenerKind: 'event',
+                order: listener.order,
+                sequence: listener.sequence,
+            })),
+            ...anyListeners.map(listener => ({
+                listener,
+                listenerKind: 'any',
+                order: listener.order,
+                sequence: listener.sequence,
+            })),
+        ];
+        const ordered = (0, order_1.orderedPluginContributions)(entries);
+        if (!ordered.length)
+            return;
+        return Promise.resolve().then(async () => {
+            for (const entry of ordered) {
+                try {
+                    if (entry.listenerKind === 'event') {
+                        const listener = entry.listener;
+                        if (listener.once && listener.fired)
+                            continue;
+                        listener.fired = true;
+                        await listener.handler(...args);
+                    }
+                    else {
+                        await entry.listener.handler(name, ...args);
+                    }
+                }
+                catch (error) {
+                    const listener = entry.listener;
+                    await this.reportEventFailure(name, (0, errors_1.wrapPluginError)(listener.record.plugin.name, `event:${name}`, listener.record.index, error, undefined, listener.record.plugin.instanceId));
+                }
+            }
+        });
+    }
+    async settleEventTasks(name, tasks) {
+        const results = await Promise.allSettled(tasks);
+        await Promise.all(results.map(async (result) => {
+            if (result.status === 'rejected')
+                await this.reportEventFailure(name, result.reason);
+        }));
+    }
+    async reportEventFailure(name, error) {
+        await Promise.all(this.getPluginErrorListeners().map(async (listener) => {
+            try {
+                await listener.handler(error, String(name));
+            }
+            catch (observerError) {
+                this.logger.warn('<Client>.events.onError', observerError, name);
+            }
+        }));
+        await this.onFail(name, error);
+    }
+}
+exports.CustomEventHandler = CustomEventHandler;
+class EventHandler extends CustomEventHandler {
+    client;
+    constructor(client) {
+        super(client);
+        this.client = client;
+    }
+    filter = (path) => path.endsWith('.js') || (!path.endsWith('.d.ts') && path.endsWith('.ts'));
     discordEvents = Object.keys(RawEvents).map(x => common_1.ReplaceRegex.camel(x.toLowerCase()));
     set(events) {
         for (const event of events) {
@@ -53,12 +175,10 @@ class EventHandler extends common_1.BaseHandler {
             if (!instance)
                 continue;
             if (typeof instance?.run !== 'function') {
-                this.logger.warn('Missing event run function');
+                this.logger.warn(`Event "${instance.data?.name ?? 'unknown'}" is missing a 'run' function, ignoring it.`);
                 continue;
             }
-            this.values[this.discordEvents.includes(instance.data.name)
-                ? common_1.ReplaceRegex.snake(instance.data.name).toUpperCase()
-                : instance.data.name] = instance;
+            this.values[(0, utils_1.normalizeEventName)(instance.data.name)] = instance;
         }
     }
     async load(eventsDir) {
@@ -70,7 +190,7 @@ class EventHandler extends common_1.BaseHandler {
             if (!events)
                 continue;
             for (const i of events) {
-                const instance = this.callback(i);
+                const instance = this.callback(this.client.runPluginHandlerTransformers('event', i));
                 if (!instance)
                     continue;
                 if (typeof instance?.run !== 'function') {
@@ -78,9 +198,8 @@ class EventHandler extends common_1.BaseHandler {
                     continue;
                 }
                 instance.__filePath = file.path;
-                this.values[this.discordEvents.includes(instance.data.name)
-                    ? common_1.ReplaceRegex.snake(instance.data.name).toUpperCase()
-                    : instance.data.name] = instance;
+                this.values[(0, utils_1.normalizeEventName)(instance.data.name)] =
+                    instance;
             }
         }
     }
@@ -166,9 +285,11 @@ class EventHandler extends common_1.BaseHandler {
         ]);
     }
     async runEvent(name, client, packet, shardId, runCache = true) {
+        const listeners = this.getPluginListeners(name);
+        const anyListeners = this.getPluginAnyListeners();
         const Event = this.values[name];
         try {
-            if (!Event || (Event.data.once && Event.fired)) {
+            if ((!Event || (Event.data.once && Event.fired)) && !listeners.length && !anyListeners.length) {
                 return runCache
                     ? this.client.cache.onPacket({
                         t: name,
@@ -176,40 +297,48 @@ class EventHandler extends common_1.BaseHandler {
                     })
                     : undefined;
             }
-            Event.fired = true;
-            const hook = await RawEvents[name]?.(client, packet);
+            let hook = packet;
+            let transformed = false;
+            try {
+                hook = await (0, utils_1.resolveRawEventData)(name, client, packet);
+                transformed = true;
+            }
+            catch (error) {
+                await this.reportEventFailure(name, error);
+            }
             if (runCache)
                 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];
-        try {
-            if (!Event || (Event.data.once && Event.fired)) {
-                // @ts-expect-error
-                return this.client.collectors.run(name, args, this.client);
+            const tasks = [];
+            if (transformed && Event && !(Event.data.once && Event.fired)) {
+                if (Event.data.once) {
+                    Event.fired = true;
+                    tasks.push(Promise.resolve()
+                        .then(() => Event.run(hook, client, shardId))
+                        .catch(error => {
+                        Event.fired = false;
+                        throw error;
+                    }));
+                }
+                else {
+                    tasks.push(Promise.resolve(Event.run(hook, client, shardId)));
+                }
+            }
+            if (transformed) {
+                const pluginTask = this.createPluginListenerTask(name, listeners, anyListeners, [hook, client, shardId]);
+                if (pluginTask)
+                    tasks.push(pluginTask);
             }
-            Event.fired = true;
-            this.client.debugger?.debug(`executed a custom event [${name}]`, Event.data.once ? 'once' : '');
-            await Promise.all([
-                Event.run(...args, this.client),
-                // @ts-expect-error
-                this.client.collectors.run(name, args, this.client),
-            ]);
+            await this.settleEventTasks(name, tasks);
         }
         catch (e) {
-            await this.onFail(name, e);
+            await this.reportEventFailure(name, e);
         }
     }
     async reload(name) {
-        if ((0, common_1.isCloudfareWorker)()) {
+        if ((0, common_1.isCloudflareWorker)()) {
             throw new common_1.SeyfertError('RELOAD_NOT_SUPPORTED', {
                 metadata: { detail: 'Reload in Cloudflare worker is not supported' },
             });
@@ -218,7 +347,7 @@ class EventHandler extends common_1.BaseHandler {
         if (!event?.__filePath)
             return null;
         delete require.cache[event.__filePath];
-        const imported = await (0, common_1.magicImport)(event.__filePath).then(x => x.default ?? x);
+        const imported = this.client.runPluginHandlerTransformers('event', await (0, common_1.magicImport)(event.__filePath).then(x => x.default ?? x));
         imported.__filePath = event.__filePath;
         this.values[name] = imported;
         return imported;

package/lib/events/hooks/application_command.d.ts

@@ -6,7 +6,7 @@ export declare const APPLICATION_COMMAND_PERMISSIONS_UPDATE: (_self: UsingClient
     guildId: string;
     permissions: {
         id: string;
-        type: import("../../types").ApplicationCommandPermissionType;
+        type: import("../..").ApplicationCommandPermissionType;
         permission: boolean;
     }[];
 };

package/lib/events/hooks/auto_moderation.d.ts

@@ -4,7 +4,7 @@ import type { GatewayAutoModerationActionExecutionDispatchData, GatewayAutoModer
 export declare const AUTO_MODERATION_ACTION_EXECUTION: (_self: UsingClient, data: GatewayAutoModerationActionExecutionDispatchData) => {
     guildId: string;
     action: {
-        type: import("../../types").AutoModerationActionType;
+        type: import("../..").AutoModerationActionType;
         metadata?: {
             channelId?: string | undefined;
             durationSeconds?: number | undefined;
@@ -12,7 +12,7 @@ export declare const AUTO_MODERATION_ACTION_EXECUTION: (_self: UsingClient, data
         } | undefined;
     };
     ruleId: string;
-    ruleTriggerType: import("../../types").AutoModerationRuleTriggerType;
+    ruleTriggerType: import("../..").AutoModerationRuleTriggerType;
     userId: string;
     channelId?: string | undefined;
     messageId?: string | undefined;