seyfert 1.0.1 → 1.1.1

package/lib/client/onmessagecreate.js

@@ -9,11 +9,11 @@ function getCommandFromContent(commandRaw, self) {
     const groupName = commandRaw.length === 3 ? commandRaw[1] : undefined;
     const subcommandName = groupName ? commandRaw[2] : commandRaw[1];
     const parent = self.commands.values.find(x => x.name === parentName);
-    const fullCommandName = `${parentName}${groupName ? ` ${groupName} ${subcommandName}` : ` ${subcommandName ?? ''}`}`;
+    const fullCommandName = `${parentName}${groupName ? ` ${groupName} ${subcommandName}` : `${subcommandName ? ` ${subcommandName}` : ''}`}`;
     if (!(parent instanceof __1.Command))
         return { fullCommandName };
     if (groupName && !parent.groups?.[groupName])
-        return getCommandFromContent([parentName, subcommandName], self);
+        return getCommandFromContent([parentName, groupName], self);
     if (subcommandName && !parent.options?.some(x => x instanceof __1.SubCommand && x.name === subcommandName))
         return getCommandFromContent([parentName], self);
     const command = groupName || subcommandName
@@ -45,12 +45,16 @@ async function onMessageCreate(self, rawMessage, shardId) {
     if (!prefix || !message.content.startsWith(prefix))
         return;
     const content = message.content.slice(prefix.length).trimStart();
-    const { fullCommandName, command, parent } = getCommandFromContent(content.split(' ').filter(x => x), self);
+    const { fullCommandName, command, parent } = getCommandFromContent(content
+        .split(' ')
+        .filter(x => x)
+        .slice(0, 3), self);
     if (!command)
         return;
     if (!command.run)
         return self.logger.warn(`${fullCommandName} command does not have 'run' callback`);
-    if (command.dm && !message.guildId)
+    if ([__1.InteractionContextTypes.BOT_DM, __1.InteractionContextTypes.PRIVATE_CHANNEL].some(i => command.contexts?.includes(i)) &&
+        !message.guildId)
         return;
     if (command.guild_id && !command.guild_id?.includes(message.guildId))
         return;
@@ -64,7 +68,10 @@ async function onMessageCreate(self, rawMessage, shardId) {
     const args = (self.options?.commands?.argsParser ?? defaultArgsParser)(content, command);
     const { options, errors } = await parseOptions(self, command, rawMessage, args, resolved);
     const optionsResolver = new __1.OptionResolver(self, options, parent, message.guildId, resolved);
-    const context = new __1.CommandContext(self, message, optionsResolver, shardId);
+    const context = new __1.CommandContext(self, message, optionsResolver, shardId, command);
+    //@ts-expect-error
+    const extendContext = self.options?.context?.(message) ?? {};
+    Object.assign(context, extendContext);
     try {
         if (command.botPermissions && message.guildId) {
             const meMember = await self.cache.members?.get(self.botId, message.guildId);
@@ -128,119 +135,192 @@ async function parseOptions(self, command, message, args, resolved) {
     const options = [];
     const errors = [];
     for (const i of (command.options ?? [])) {
-        let value;
-        let indexAttachment = -1;
-        switch (i.type) {
-            case v10_1.ApplicationCommandOptionType.Attachment:
-                if (message.attachments[++indexAttachment]) {
-                    value = message.attachments[indexAttachment].id;
-                    resolved.attachments[value] = message.attachments[indexAttachment];
-                }
-                break;
-            case v10_1.ApplicationCommandOptionType.Boolean:
-                if (args[i.name]) {
-                    value = ['yes', 'y', 'true', 'treu'].includes(args[i.name].toLowerCase());
-                }
-                break;
-            case v10_1.ApplicationCommandOptionType.Channel:
-                {
-                    const rawId = message.content.match(/(?<=<#)[0-9]{17,19}(?=>)/g)?.find(x => args[i.name]?.includes(x));
-                    if (rawId) {
-                        const channel = i.required ? await self.channels.fetch(rawId) : await self.cache.channels?.get(rawId);
-                        if (channel) {
-                            if ('channel_types' in i) {
-                                if (!i.channel_types.includes(channel.type)) {
-                                    errors.push({
-                                        name: i.name,
-                                        error: `The entered channel type is not one of ${i
-                                            .channel_types.map(t => v10_1.ChannelType[t])
-                                            .join(', ')}`,
-                                    });
-                                    break;
+        try {
+            let value;
+            let indexAttachment = -1;
+            switch (i.type) {
+                case v10_1.ApplicationCommandOptionType.Attachment:
+                    if (message.attachments[++indexAttachment]) {
+                        value = message.attachments[indexAttachment].id;
+                        resolved.attachments[value] = message.attachments[indexAttachment];
+                    }
+                    break;
+                case v10_1.ApplicationCommandOptionType.Boolean:
+                    if (args[i.name]) {
+                        value = ['yes', 'y', 'true', 'treu'].includes(args[i.name].toLowerCase());
+                    }
+                    break;
+                case v10_1.ApplicationCommandOptionType.Channel:
+                    {
+                        const rawId = message.content.match(/(?<=<#)[0-9]{17,19}(?=>)/g)?.find(x => args[i.name]?.includes(x)) ||
+                            args[i.name]?.match(/[0-9]{17,19}/g)?.[0];
+                        if (rawId) {
+                            const channel = (await self.cache.channels?.get(rawId)) ?? (i.required ? await self.channels.fetch(rawId) : undefined);
+                            if (channel) {
+                                if ('channel_types' in i) {
+                                    if (!i.channel_types.includes(channel.type)) {
+                                        errors.push({
+                                            name: i.name,
+                                            error: `The entered channel type is not one of ${i
+                                                .channel_types.map(t => v10_1.ChannelType[t])
+                                                .join(', ')}`,
+                                        });
+                                        break;
+                                    }
                                 }
+                                value = rawId;
+                                resolved.channels[rawId] = channel;
                             }
-                            value = rawId;
-                            //@ts-expect-error
-                            resolved.channels[rawId] = channel;
                         }
                     }
-                }
-                break;
-            case v10_1.ApplicationCommandOptionType.Mentionable:
-                {
-                    const matches = message.content.match(/<@[0-9]{17,19}(?=>)|<@&[0-9]{17,19}(?=>)/g) ?? [];
-                    for (const match of matches) {
-                        if (match.includes('&')) {
-                            const rawId = match.slice(3);
-                            if (rawId) {
-                                const role = i.required
-                                    ? (await self.roles.list(message.guild_id)).find(x => x.id === rawId)
-                                    : await self.cache.roles?.get(rawId);
-                                if (role) {
-                                    value = rawId;
-                                    //@ts-expect-error
-                                    resolved.roles[rawId] = role;
+                    break;
+                case v10_1.ApplicationCommandOptionType.Mentionable:
+                    {
+                        const matches = message.content.match(/<@[0-9]{17,19}(?=>)|<@&[0-9]{17,19}(?=>)/g) ?? [];
+                        for (const match of matches) {
+                            if (match.includes('&')) {
+                                const rawId = match.slice(3);
+                                if (rawId) {
+                                    const role = (await self.cache.roles?.get(rawId)) ??
+                                        (i.required ? (await self.roles.list(message.guild_id)).find(x => x.id === rawId) : undefined);
+                                    if (role) {
+                                        value = rawId;
+                                        resolved.roles[rawId] = role;
+                                        break;
+                                    }
+                                }
+                            }
+                            else {
+                                const rawId = match.slice(2);
+                                const raw = message.mentions.find(x => rawId === x.id);
+                                if (raw) {
+                                    const { member, ...user } = raw;
+                                    value = raw.id;
+                                    resolved.users[raw.id] = user;
+                                    if (member)
+                                        resolved.members[raw.id] = member;
                                     break;
                                 }
                             }
                         }
-                        else {
-                            const rawId = match.slice(2);
-                            const raw = message.mentions.find(x => rawId === x.id);
+                    }
+                    break;
+                case v10_1.ApplicationCommandOptionType.Role:
+                    {
+                        const rawId = message.mention_roles.find(x => args[i.name]?.includes(x)) || args[i.name]?.match(/[0-9]{17,19}/g)?.[0];
+                        if (rawId) {
+                            const role = (await self.cache.roles?.get(rawId)) ??
+                                (i.required ? (await self.roles.list(message.guild_id)).find(x => x.id === rawId) : undefined);
+                            if (role) {
+                                value = rawId;
+                                resolved.roles[rawId] = role;
+                            }
+                        }
+                    }
+                    break;
+                case v10_1.ApplicationCommandOptionType.User:
+                    {
+                        const rawId = message.mentions.find(x => args[i.name]?.includes(x.id))?.id || args[i.name]?.match(/[0-9]{17,19}/g)?.[0];
+                        if (rawId) {
+                            const raw = message.mentions.find(x => args[i.name]?.includes(x.id)) ??
+                                (await self.cache.users?.get(rawId)) ??
+                                (i.required ? await self.users.fetch(rawId) : undefined);
                             if (raw) {
                                 value = raw.id;
-                                resolved.users[raw.id] = raw;
-                                break;
+                                if (raw instanceof __1.User) {
+                                    resolved.users[raw.id] = raw;
+                                    if (message.guild_id) {
+                                        const member = message.mentions.find(x => args[i.name]?.includes(x.id))?.member ??
+                                            (await self.cache.members?.get(rawId, message.guild_id)) ??
+                                            (i.required ? await self.members.fetch(rawId, message.guild_id) : undefined);
+                                        if (member)
+                                            resolved.members[raw.id] = member;
+                                    }
+                                }
+                                else {
+                                    const { member, ...user } = raw;
+                                    resolved.users[user.id] = user;
+                                    if (member)
+                                        resolved.members[user.id] = member;
+                                }
                             }
                         }
                     }
-                }
-                break;
-            case v10_1.ApplicationCommandOptionType.Role:
-                {
-                    const rawId = message.mention_roles.find(x => args[i.name]?.includes(x));
-                    if (rawId) {
-                        const role = i.required
-                            ? (await self.roles.list(message.guild_id)).find(x => x.id === rawId) //why, discord, why
-                            : await self.cache.roles?.get(rawId);
-                        if (role) {
-                            value = rawId;
-                            //@ts-expect-error
-                            resolved.roles[rawId] = role;
+                    break;
+                case v10_1.ApplicationCommandOptionType.String:
+                    {
+                        value = args[i.name];
+                        const option = i;
+                        if (value) {
+                            if (option.min_length) {
+                                if (value.length < option.min_length) {
+                                    value = undefined;
+                                    errors.push({
+                                        name: i.name,
+                                        error: `The entered string has less than ${option.min_length} characters. The minimum required is ${option.min_length} characters.`,
+                                    });
+                                    break;
+                                }
+                            }
+                            if (option.max_length) {
+                                if (value.length > option.max_length) {
+                                    value = undefined;
+                                    errors.push({
+                                        name: i.name,
+                                        error: `The entered string has more than ${option.max_length} characters. The maximum required is ${option.max_length} characters.`,
+                                    });
+                                    break;
+                                }
+                            }
+                            if (option.choices?.length) {
+                                if (!option.choices.some(x => x.name === value)) {
+                                    value = undefined;
+                                    errors.push({
+                                        name: i.name,
+                                        error: `The entered choice is invalid. Please choose one of the following options: ${option.choices
+                                            .map(x => x.name)
+                                            .join(', ')}.`,
+                                    });
+                                    break;
+                                }
+                                value = option.choices.find(x => x.name === value).value;
+                            }
                         }
                     }
-                }
-                break;
-            case v10_1.ApplicationCommandOptionType.User:
-                {
-                    const raw = message.mentions.find(x => args[i.name]?.includes(x.id));
-                    if (raw) {
-                        value = raw.id;
-                        resolved.users[raw.id] = raw;
-                    }
-                }
-                break;
-            case v10_1.ApplicationCommandOptionType.String:
-                {
-                    value = args[i.name];
-                    const option = i;
-                    if (value) {
-                        if (option.min_length) {
-                            if (value.length < option.min_length) {
+                    break;
+                case v10_1.ApplicationCommandOptionType.Number:
+                case v10_1.ApplicationCommandOptionType.Integer:
+                    {
+                        value = Number(args[i.name]);
+                        if (args[i.name] === undefined) {
+                            value = undefined;
+                            break;
+                        }
+                        if (Number.isNaN(value)) {
+                            value = undefined;
+                            errors.push({
+                                name: i.name,
+                                error: 'The entered choice is an invalid number.',
+                            });
+                            break;
+                        }
+                        const option = i;
+                        if (option.min_value) {
+                            if (value < option.min_value) {
                                 value = undefined;
                                 errors.push({
                                     name: i.name,
-                                    error: `The entered string has less than ${option.min_length} characters. The minimum required is ${option.min_length} characters.`,
+                                    error: `The entered number is less than ${option.min_value}. The minimum allowed is ${option.min_value}`,
                                 });
                                 break;
                             }
                         }
-                        if (option.max_length) {
-                            if (value.length > option.max_length) {
+                        if (option.max_value) {
+                            if (value > option.max_value) {
                                 value = undefined;
                                 errors.push({
                                     name: i.name,
-                                    error: `The entered string has more than ${option.max_length} characters. The maximum required is ${option.max_length} characters.`,
+                                    error: `The entered number is greater than ${option.max_value}. The maximum allowed is ${option.max_value}`,
                                 });
                                 break;
                             }
@@ -259,68 +339,27 @@ async function parseOptions(self, command, message, args, resolved) {
                             value = option.choices.find(x => x.name === value).value;
                         }
                     }
-                }
-                break;
-            case v10_1.ApplicationCommandOptionType.Number:
-            case v10_1.ApplicationCommandOptionType.Integer:
-                {
-                    value = Number(args[i.name]);
-                    if (args[i.name] === undefined) {
-                        value = undefined;
-                        break;
-                    }
-                    if (Number.isNaN(value)) {
-                        value = undefined;
-                        errors.push({
-                            name: i.name,
-                            error: 'The entered choice is an invalid number.',
-                        });
-                        break;
-                    }
-                    const option = i;
-                    if (option.min_value) {
-                        if (value < option.min_value) {
-                            value = undefined;
-                            errors.push({
-                                name: i.name,
-                                error: `The entered number is less than ${option.min_value}. The minimum allowed is ${option.min_value}`,
-                            });
-                            break;
-                        }
-                    }
-                    if (option.max_value) {
-                        if (value > option.max_value) {
-                            value = undefined;
-                            errors.push({
-                                name: i.name,
-                                error: `The entered number is greater than ${option.max_value}. The maximum allowed is ${option.max_value}`,
-                            });
-                            break;
-                        }
-                    }
-                    if (option.choices?.length) {
-                        if (!option.choices.some(x => x.name === value)) {
-                            value = undefined;
-                            errors.push({
-                                name: i.name,
-                                error: `The entered choice is invalid. Please choose one of the following options: ${option.choices
-                                    .map(x => x.name)
-                                    .join(', ')}.`,
-                            });
-                            break;
-                        }
-                        value = option.choices.find(x => x.name === value).value;
-                    }
-                }
-                break;
-            default:
-                break;
+                    break;
+                default:
+                    break;
+            }
+            if (value !== undefined) {
+                options.push({
+                    name: i.name,
+                    type: i.type,
+                    value,
+                });
+            }
+            else if (i.required)
+                errors.push({
+                    error: 'Option is required but returned undefined',
+                    name: i.name,
+                });
         }
-        if (value !== undefined) {
-            options.push({
+        catch (e) {
+            errors.push({
+                error: e && typeof e === 'object' && 'message' in e ? e.message : `${e}`,
                 name: i.name,
-                type: i.type,
-                value,
             });
         }
     }

package/lib/client/workerclient.d.ts

@@ -6,18 +6,18 @@
 import type { Cache } from '../cache';
 import type { GatewayDispatchPayload, When } from '../common';
 import { Logger, type DeepPartial } from '../common';
-import { EventHandler } from '../events';
+import { type EventHandlerLike } from '../events';
 import { ClientUser } from '../structures';
 import { Shard, type ShardManagerOptions } from '../websocket';
 import type { WorkerShardInfo } from '../websocket/discord/worker';
 import type { ManagerMessages } from '../websocket/discord/workermanager';
-import type { BaseClientOptions, StartOptions } from './base';
+import type { BaseClientOptions, ServicesOptions, StartOptions } from './base';
 import { BaseClient } from './base';
 import type { Client } from './client';
 export declare class WorkerClient<Ready extends boolean = boolean> extends BaseClient {
     private __handleGuilds?;
     logger: Logger;
-    events: EventHandler;
+    events?: EventHandlerLike;
     me: When<Ready, ClientUser>;
     promises: Map<string, {
         resolve: (value: any) => void;
@@ -28,8 +28,14 @@ export declare class WorkerClient<Ready extends boolean = boolean> extends BaseC
     constructor(options?: WorkerClientOptions);
     get workerId(): number;
     get latency(): number;
+    setServices({ ...rest }: ServicesOptions & {
+        handlers?: ServicesOptions['handlers'] & {
+            events?: EventHandlerLike;
+        };
+    }): void;
     start(options?: Omit<DeepPartial<StartOptions>, 'httpConnection' | 'token' | 'connection'>): Promise<void>;
     loadEvents(dir?: string): Promise<void>;
+    postMessage(body: any): boolean | void;
     protected handleManagerMessages(data: ManagerMessages): Promise<any>;
     private generateNonce;
     private generateSendPromise;